From bc3aa9467ae1e2d0ea1727093af9b0af14965e69 Mon Sep 17 00:00:00 2001 From: mat <27899617+mat-1@users.noreply.github.com> Date: Fri, 7 Oct 2022 20:12:36 -0500 Subject: [PATCH] Replace impl Read with Cursor<&[u8]> (#26) * Start getting rid of Cursor * try to make the tests pass and fail * make the tests pass * remove unused uses * fix clippy warnings * fix potential OOM exploits * fix OOM in az-nbt * fix nbt benchmark * fix a test * start replacing it with Cursor> * wip * fix all the issues * fix all tests * fix nbt benchmark * fix warnings --- azalea-block/src/lib.rs | 4 +- azalea-buf/azalea-buf-macros/src/lib.rs | 4 +- azalea-buf/src/definitions.rs | 4 +- azalea-buf/src/lib.rs | 73 +++++---- azalea-buf/src/read.rs | 145 ++++++++++-------- azalea-buf/src/serializable_uuid.rs | 6 +- azalea-chat/src/component.rs | 4 +- azalea-client/src/client.rs | 8 +- azalea-core/src/difficulty.rs | 4 +- azalea-core/src/game_type.rs | 6 +- azalea-core/src/particle/mod.rs | 6 +- azalea-core/src/position.rs | 16 +- azalea-core/src/resource_location.rs | 8 +- azalea-core/src/slot.rs | 4 +- azalea-nbt/benches/my_benchmark.rs | 16 +- azalea-nbt/src/decode.rs | 56 ++++--- azalea-nbt/src/error.rs | 8 +- azalea-nbt/src/lib.rs | 5 +- azalea-nbt/tests/tests.rs | 24 +-- .../azalea-protocol-macros/src/lib.rs | 11 +- azalea-protocol/src/connect.rs | 5 + azalea-protocol/src/lib.rs | 21 ++- .../game/clientbound_boss_event_packet.rs | 8 +- .../clientbound_command_suggestions_packet.rs | 4 +- .../game/clientbound_commands_packet.rs | 9 +- .../game/clientbound_explode_packet.rs | 6 +- .../clientbound_level_particles_packet.rs | 4 +- .../game/clientbound_map_item_data_packet.rs | 5 +- .../clientbound_player_abilities_packet.rs | 4 +- .../game/clientbound_player_chat_packet.rs | 4 +- .../game/clientbound_player_info_packet.rs | 4 +- .../clientbound_player_position_packet.rs | 4 +- .../packets/game/clientbound_recipe_packet.rs | 5 +- ...lientbound_section_blocks_update_packet.rs | 4 +- .../game/clientbound_set_equipment_packet.rs | 6 +- .../game/clientbound_set_objective_packet.rs | 4 +- .../clientbound_set_player_team_packet.rs | 5 +- .../game/clientbound_set_score_packet.rs | 4 +- .../game/clientbound_stop_sound_packet.rs | 5 +- .../clientbound_update_advancements_packet.rs | 3 +- .../clientbound_update_attributes_packet.rs | 4 +- .../game/clientbound_update_recipes_packet.rs | 6 +- .../game/clientbound_update_tags_packet.rs | 10 +- .../game/serverbound_interact_packet.rs | 4 +- .../serverbound_player_abilities_packet.rs | 3 +- .../game/serverbound_player_input_packet.rs | 4 +- .../serverbound_seen_advancements_packet.rs | 3 +- .../serverbound_set_command_block_packet.rs | 3 +- .../serverbound_set_jigsaw_block_packet.rs | 5 +- .../serverbound_set_structure_block_packet.rs | 4 +- .../game/serverbound_use_item_on_packet.rs | 4 +- .../clientbound_login_compression_packet.rs | 32 +--- .../packets/login/serverbound_hello_packet.rs | 6 +- .../packets/login/serverbound_key_packet.rs | 4 +- azalea-protocol/src/packets/mod.rs | 6 +- .../clientbound_status_response_packet.rs | 32 ++-- azalea-protocol/src/read.rs | 98 +++++++++--- azalea-world/src/chunk_storage.rs | 11 +- azalea-world/src/entity/data.rs | 6 +- azalea-world/src/lib.rs | 4 +- azalea-world/src/palette.rs | 6 +- 61 files changed, 435 insertions(+), 346 deletions(-) mode change 100755 => 100644 azalea-protocol/src/connect.rs mode change 100755 => 100644 azalea-protocol/src/read.rs diff --git a/azalea-block/src/lib.rs b/azalea-block/src/lib.rs index cc7ddf73..685aed92 100644 --- a/azalea-block/src/lib.rs +++ b/azalea-block/src/lib.rs @@ -5,7 +5,7 @@ use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufVarWritable pub use behavior::BlockBehavior; pub use blocks::*; use std::{ - io::{Read, Write}, + io::{Cursor, Write}, mem, }; @@ -39,7 +39,7 @@ impl TryFrom for BlockState { } impl McBufReadable for BlockState { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let state_id = u32::var_read_from(buf)?; Self::try_from(state_id).map_err(|_| BufReadError::UnexpectedEnumVariant { id: state_id as i32, diff --git a/azalea-buf/azalea-buf-macros/src/lib.rs b/azalea-buf/azalea-buf-macros/src/lib.rs index 288f2416..801b7b71 100644 --- a/azalea-buf/azalea-buf-macros/src/lib.rs +++ b/azalea-buf/azalea-buf-macros/src/lib.rs @@ -41,7 +41,7 @@ fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::TokenSt quote! { impl azalea_buf::McBufReadable for #ident { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result { #(#read_fields)* Ok(#ident { #(#read_field_names: #read_field_names),* @@ -105,7 +105,7 @@ fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::TokenSt quote! { impl azalea_buf::McBufReadable for #ident { - fn read_from(buf: &mut impl std::io::Read) -> Result + fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result { let id = azalea_buf::McBufVarReadable::var_read_from(buf)?; match id { diff --git a/azalea-buf/src/definitions.rs b/azalea-buf/src/definitions.rs index ae7a7407..77309c46 100644 --- a/azalea-buf/src/definitions.rs +++ b/azalea-buf/src/definitions.rs @@ -2,10 +2,10 @@ use std::ops::Deref; /// A Vec that isn't prefixed by a VarInt with the size. #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UnsizedByteArray(Vec); +pub struct UnsizedByteArray(pub Vec); impl Deref for UnsizedByteArray { - type Target = Vec; + type Target = [u8]; fn deref(&self) -> &Self::Target { &self.0 diff --git a/azalea-buf/src/lib.rs b/azalea-buf/src/lib.rs index b8daa325..2c42f2ca 100644 --- a/azalea-buf/src/lib.rs +++ b/azalea-buf/src/lib.rs @@ -12,7 +12,7 @@ mod write; pub use azalea_buf_macros::*; pub use definitions::*; -pub use read::{read_varint_async, BufReadError, McBufReadable, McBufVarReadable}; +pub use read::{BufReadError, McBufReadable, McBufVarReadable}; pub use serializable_uuid::*; pub use write::{McBufVarWritable, McBufWritable}; @@ -23,7 +23,7 @@ const MAX_STRING_LENGTH: u16 = 32767; #[cfg(test)] mod tests { use super::*; - use std::{collections::HashMap, io::Cursor}; + use std::collections::HashMap; #[test] fn test_write_varint() { @@ -74,44 +74,44 @@ mod tests { #[test] fn test_read_varint() { - let mut buf = Cursor::new(vec![0]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 0); + let buf = &mut &vec![0][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 0); - let mut buf = Cursor::new(vec![1]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 1); + let buf = &mut &vec![1][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 1); - let mut buf = Cursor::new(vec![2]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2); + let buf = &mut &vec![2][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 2); - let mut buf = Cursor::new(vec![127]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 127); + let buf = &mut &vec![127][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 127); - let mut buf = Cursor::new(vec![128, 1]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 128); + let buf = &mut &vec![128, 1][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 128); - let mut buf = Cursor::new(vec![255, 1]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 255); + let buf = &mut &vec![255, 1][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 255); - let mut buf = Cursor::new(vec![221, 199, 1]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 25565); + let buf = &mut &vec![221, 199, 1][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 25565); - let mut buf = Cursor::new(vec![255, 255, 127]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2097151); + let buf = &mut &vec![255, 255, 127][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 2097151); - let mut buf = Cursor::new(vec![255, 255, 255, 255, 7]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2147483647); + let buf = &mut &vec![255, 255, 255, 255, 7][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647); - let mut buf = Cursor::new(vec![255, 255, 255, 255, 15]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), -1); + let buf = &mut &vec![255, 255, 255, 255, 15][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), -1); - let mut buf = Cursor::new(vec![128, 128, 128, 128, 8]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), -2147483648); + let buf = &mut &vec![128, 128, 128, 128, 8][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), -2147483648); } #[test] fn test_read_varint_longer() { - let mut buf = Cursor::new(vec![138, 56, 0, 135, 56, 123]); - assert_eq!(i32::var_read_from(&mut buf).unwrap(), 7178); + let buf = &mut &vec![138, 56, 0, 135, 56, 123][..]; + assert_eq!(i32::var_read_from(buf).unwrap(), 7178); } #[test] @@ -123,8 +123,8 @@ mod tests { dbg!(&buf); - let mut buf = Cursor::new(buf); - let result = Vec::::read_from(&mut buf).unwrap(); + let buf = &mut &buf[..]; + let result = Vec::::read_from(buf).unwrap(); assert_eq!(result, original_vec); } @@ -133,9 +133,9 @@ mod tests { let mut buf = Vec::new(); vec![1, 2, 3].var_write_into(&mut buf).unwrap(); - let mut buf = Cursor::new(buf); + let buf = &mut &buf[..]; - let result = Vec::::var_read_from(&mut buf).unwrap(); + let result = Vec::::var_read_from(buf).unwrap(); assert_eq!(result, vec![1, 2, 3]); } @@ -149,20 +149,19 @@ mod tests { let mut buf = Vec::new(); original_map.var_write_into(&mut buf).unwrap(); - let mut buf = Cursor::new(buf); + let buf = &mut &buf[..]; - let result = HashMap::::var_read_from(&mut buf).unwrap(); + let result = HashMap::::var_read_from(buf).unwrap(); assert_eq!(result, original_map); } #[test] fn test_long() { - let mut buf = Vec::new(); - 123456u64.write_into(&mut buf).unwrap(); + let buf: &mut Vec = &mut Vec::new(); + 123456u64.write_into(buf).unwrap(); - let mut buf = Cursor::new(buf); - - assert_eq!(u64::read_from(&mut buf).unwrap(), 123456); + let buf = &mut &buf[..]; + assert_eq!(u64::read_from(buf).unwrap(), 123456); } } diff --git a/azalea-buf/src/read.rs b/azalea-buf/src/read.rs index 78c858e4..29f351c6 100644 --- a/azalea-buf/src/read.rs +++ b/azalea-buf/src/read.rs @@ -1,8 +1,11 @@ use super::{UnsizedByteArray, MAX_STRING_LENGTH}; use byteorder::{ReadBytesExt, BE}; -use std::{collections::HashMap, hash::Hash, io::Read}; +use std::{ + collections::HashMap, + hash::Hash, + io::{Cursor, Read}, +}; use thiserror::Error; -use tokio::io::{AsyncRead, AsyncReadExt}; #[derive(Error, Debug)] pub enum BufReadError { @@ -26,6 +29,11 @@ pub enum BufReadError { UnexpectedEnumVariant { id: i32 }, #[error("Unexpected enum variant {id}")] UnexpectedStringEnumVariant { id: String }, + #[error("Tried to read {attempted_read} bytes but there were only {actual_read}")] + UnexpectedEof { + attempted_read: usize, + actual_read: usize, + }, #[error("{0}")] Custom(String), #[cfg(feature = "serde_json")] @@ -33,7 +41,20 @@ pub enum BufReadError { Deserialization(#[from] serde_json::Error), } -fn read_utf_with_len(buf: &mut impl Read, max_length: u32) -> Result { +fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8], BufReadError> { + if length > buf.get_ref().len() { + return Err(BufReadError::UnexpectedEof { + attempted_read: length, + actual_read: buf.get_ref().len(), + }); + } + let initial_position = buf.position() as usize; + buf.set_position(buf.position() + length as u64); + let data = &buf.get_ref()[initial_position..initial_position + length]; + Ok(data) +} + +fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result { let length = u32::var_read_from(buf)?; // i don't know why it's multiplied by 4 but it's like that in mojang's code so if length as u32 > max_length * 4 { @@ -43,12 +64,10 @@ fn read_utf_with_len(buf: &mut impl Read, max_length: u32) -> Result length as usize { return Err(BufReadError::StringLengthTooLong { length, max_length }); } @@ -58,37 +77,37 @@ fn read_utf_with_len(buf: &mut impl Read, max_length: u32) -> Result Result { - let mut buffer = [0]; - let mut ans = 0; - for i in 0..5 { - reader.read_exact(&mut buffer).await?; - ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i); - if buffer[0] & 0b1000_0000 == 0 { - break; - } - } - Ok(ans) -} +// pub async fn read_varint_async( +// reader: &mut (dyn AsyncRead + Unpin + Send), +// ) -> Result { +// let mut buffer = [0]; +// let mut ans = 0; +// for i in 0..5 { +// reader.read_exact(&mut buffer).await?; +// ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i); +// if buffer[0] & 0b1000_0000 == 0 { +// break; +// } +// } +// Ok(ans) +// } pub trait McBufReadable where Self: Sized, { - fn read_from(buf: &mut impl Read) -> Result; + fn read_from(buf: &mut Cursor<&[u8]>) -> Result; } pub trait McBufVarReadable where Self: Sized, { - fn var_read_from(buf: &mut impl Read) -> Result; + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result; } impl McBufReadable for i32 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i32::()?) } } @@ -96,7 +115,7 @@ impl McBufReadable for i32 { impl McBufVarReadable for i32 { // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67 /// Read a single varint from the reader and return the value - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { let mut buffer = [0]; let mut ans = 0; for i in 0..5 { @@ -112,7 +131,7 @@ impl McBufVarReadable for i32 { impl McBufVarReadable for i64 { // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L54 - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { let mut buffer = [0]; let mut ans = 0; for i in 0..8 { @@ -127,25 +146,26 @@ impl McBufVarReadable for i64 { } } impl McBufVarReadable for u64 { - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { i64::var_read_from(buf).map(|i| i as u64) } } impl McBufReadable for UnsizedByteArray { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { // read to end of the buffer - let mut bytes = vec![]; - buf.read_to_end(&mut bytes) - .map_err(|_| BufReadError::CouldNotReadBytes)?; - Ok(bytes.into()) + let data = buf.get_ref()[buf.position() as usize..].to_vec(); + buf.set_position((buf.position()) + data.len() as u64); + Ok(UnsizedByteArray(data)) } } impl McBufReadable for Vec { - default fn read_from(buf: &mut impl Read) -> Result { + default fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = u32::var_read_from(buf)? as usize; - let mut contents = Vec::with_capacity(length); + // we don't set the capacity here so we can't get exploited into + // allocating a bunch + let mut contents = vec![]; for _ in 0..length { contents.push(T::read_from(buf)?); } @@ -154,9 +174,9 @@ impl McBufReadable for Vec { } impl McBufReadable for HashMap { - default fn read_from(buf: &mut impl Read) -> Result { + default fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = i32::var_read_from(buf)? as usize; - let mut contents = HashMap::with_capacity(length); + let mut contents = HashMap::new(); for _ in 0..length { contents.insert(K::read_from(buf)?, V::read_from(buf)?); } @@ -167,9 +187,9 @@ impl McBufReadable impl McBufVarReadable for HashMap { - default fn var_read_from(buf: &mut impl Read) -> Result { + default fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = i32::var_read_from(buf)? as usize; - let mut contents = HashMap::with_capacity(length); + let mut contents = HashMap::new(); for _ in 0..length { contents.insert(K::read_from(buf)?, V::var_read_from(buf)?); } @@ -178,55 +198,52 @@ impl McBufVarRe } impl McBufReadable for Vec { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = i32::var_read_from(buf)? as usize; - let mut buffer = vec![0; length]; - buf.read_exact(&mut buffer) - .map_err(|_| BufReadError::CouldNotReadBytes)?; - Ok(buffer) + read_bytes(buf, length).map(|b| b.to_vec()) } } impl McBufReadable for String { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { read_utf_with_len(buf, MAX_STRING_LENGTH.into()) } } impl McBufReadable for u32 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(i32::read_from(buf)? as u32) } } impl McBufVarReadable for u32 { - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(i32::var_read_from(buf)? as u32) } } impl McBufReadable for u16 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { i16::read_from(buf).map(|i| i as u16) } } impl McBufReadable for i16 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i16::()?) } } impl McBufVarReadable for u16 { - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(i32::var_read_from(buf)? as u16) } } impl McBufVarReadable for Vec { - fn var_read_from(buf: &mut impl Read) -> Result { + fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = i32::var_read_from(buf)? as usize; - let mut contents = Vec::with_capacity(length); + let mut contents = Vec::new(); for _ in 0..length { contents.push(T::var_read_from(buf)?); } @@ -235,49 +252,49 @@ impl McBufVarReadable for Vec { } impl McBufReadable for i64 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_i64::()?) } } impl McBufReadable for u64 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { i64::read_from(buf).map(|i| i as u64) } } impl McBufReadable for bool { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(u8::read_from(buf)? != 0) } } impl McBufReadable for u8 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_u8()?) } } impl McBufReadable for i8 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { u8::read_from(buf).map(|i| i as i8) } } impl McBufReadable for f32 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_f32::()?) } } impl McBufReadable for f64 { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(buf.read_f64::()?) } } impl McBufReadable for Option { - default fn read_from(buf: &mut impl Read) -> Result { + default fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let present = bool::read_from(buf)?; Ok(if present { Some(T::read_from(buf)?) @@ -288,7 +305,7 @@ impl McBufReadable for Option { } impl McBufVarReadable for Option { - default fn var_read_from(buf: &mut impl Read) -> Result { + default fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result { let present = bool::read_from(buf)?; Ok(if present { Some(T::var_read_from(buf)?) @@ -300,13 +317,13 @@ impl McBufVarReadable for Option { // [String; 4] impl McBufReadable for [T; N] { - default fn read_from(buf: &mut impl Read) -> Result { + default fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let mut contents = Vec::with_capacity(N); for _ in 0..N { contents.push(T::read_from(buf)?); } contents.try_into().map_err(|_| { - panic!("Panic is not possible since the Vec is the same size as the array") + unreachable!("Panic is not possible since the Vec is the same size as the array") }) } } diff --git a/azalea-buf/src/serializable_uuid.rs b/azalea-buf/src/serializable_uuid.rs index 66cdda73..dc251269 100644 --- a/azalea-buf/src/serializable_uuid.rs +++ b/azalea-buf/src/serializable_uuid.rs @@ -1,5 +1,5 @@ use crate::{read::BufReadError, McBufReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use uuid::Uuid; pub trait SerializableUuid { @@ -33,7 +33,7 @@ impl SerializableUuid for Uuid { } impl McBufReadable for Uuid { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(Uuid::from_int_array([ u32::read_from(buf)?, u32::read_from(buf)?, @@ -80,7 +80,7 @@ mod tests { u.write_into(&mut buf).unwrap(); println!("{:?}", buf); assert_eq!(buf.len(), 16); - let u2 = Uuid::read_from(&mut buf.as_slice()).unwrap(); + let u2 = Uuid::read_from(&mut Cursor::new(&buf)).unwrap(); assert_eq!(u, u2); } } diff --git a/azalea-chat/src/component.rs b/azalea-chat/src/component.rs index 6cf1ec09..81224d9f 100755 --- a/azalea-chat/src/component.rs +++ b/azalea-chat/src/component.rs @@ -1,6 +1,6 @@ use std::{ fmt::Display, - io::{Read, Write}, + io::{Cursor, Write}, }; use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; @@ -239,7 +239,7 @@ impl<'de> Deserialize<'de> for Component { } impl McBufReadable for Component { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let string = String::read_from(buf)?; let json: serde_json::Value = serde_json::from_str(string.as_str())?; let component = Component::deserialize(json)?; diff --git a/azalea-client/src/client.rs b/azalea-client/src/client.rs index d3363ff2..ed0a75e7 100644 --- a/azalea-client/src/client.rs +++ b/azalea-client/src/client.rs @@ -31,7 +31,11 @@ use azalea_world::{ }; use log::{debug, error, warn}; use parking_lot::Mutex; -use std::{fmt::Debug, io, sync::Arc}; +use std::{ + fmt::Debug, + io::{self, Cursor}, + sync::Arc, +}; use thiserror::Error; use tokio::{ io::AsyncWriteExt, @@ -509,7 +513,7 @@ impl Client { client .dimension .lock() - .replace_with_packet_data(&pos, &mut p.chunk_data.data.as_slice()) + .replace_with_packet_data(&pos, &mut Cursor::new(&p.chunk_data.data)) .unwrap(); } ClientboundGamePacket::LightUpdate(p) => { diff --git a/azalea-core/src/difficulty.rs b/azalea-core/src/difficulty.rs index 65950e8d..5cc2f9fa 100755 --- a/azalea-core/src/difficulty.rs +++ b/azalea-core/src/difficulty.rs @@ -1,6 +1,6 @@ use std::{ fmt::{Debug, Error, Formatter}, - io::{Read, Write}, + io::{Cursor, Write}, }; use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; @@ -67,7 +67,7 @@ impl Difficulty { } impl McBufReadable for Difficulty { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(Difficulty::by_id(u8::read_from(buf)?)) } } diff --git a/azalea-core/src/game_type.rs b/azalea-core/src/game_type.rs index f3f056a4..635ee6fe 100755 --- a/azalea-core/src/game_type.rs +++ b/azalea-core/src/game_type.rs @@ -1,5 +1,5 @@ use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Hash, Copy, Clone, Debug)] pub enum GameType { @@ -79,7 +79,7 @@ impl GameType { } impl McBufReadable for GameType { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let id = u8::read_from(buf)?; GameType::from_id(id).ok_or(BufReadError::UnexpectedEnumVariant { id: id as i32 }) } @@ -108,7 +108,7 @@ impl From for Option { } impl McBufReadable for OptionalGameType { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let id = i8::read_from(buf)?; GameType::from_optional_id(id).ok_or(BufReadError::UnexpectedEnumVariant { id: id as i32 }) } diff --git a/azalea-core/src/particle/mod.rs b/azalea-core/src/particle/mod.rs index c2fa3337..8087de51 100644 --- a/azalea-core/src/particle/mod.rs +++ b/azalea-core/src/particle/mod.rs @@ -1,6 +1,6 @@ use crate::{BlockPos, Slot}; use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufVarReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Debug, Clone, McBuf)] pub struct Particle { @@ -153,7 +153,7 @@ pub struct VibrationParticle { } impl ParticleData { - pub fn read_from_particle_id(buf: &mut impl Read, id: u32) -> Result { + pub fn read_from_particle_id(buf: &mut Cursor<&[u8]>, id: u32) -> Result { Ok(match id { 0 => ParticleData::AmbientEntityEffect, 1 => ParticleData::AngryVillager, @@ -249,7 +249,7 @@ impl ParticleData { } impl McBufReadable for ParticleData { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let id = u32::var_read_from(buf)?; ParticleData::read_from_particle_id(buf, id) } diff --git a/azalea-core/src/position.rs b/azalea-core/src/position.rs index d47072d4..d408d817 100644 --- a/azalea-core/src/position.rs +++ b/azalea-core/src/position.rs @@ -1,7 +1,7 @@ use crate::ResourceLocation; use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; use std::{ - io::{Read, Write}, + io::{Cursor, Write}, ops::{Add, Mul, Rem}, }; @@ -301,7 +301,7 @@ const Z_OFFSET: u64 = PACKED_Y_LENGTH; const X_OFFSET: u64 = PACKED_Y_LENGTH + PACKED_Z_LENGTH; impl McBufReadable for BlockPos { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let val = i64::read_from(buf)?; let x = (val << (64 - X_OFFSET - PACKED_X_LENGTH) >> (64 - PACKED_X_LENGTH)) as i32; let y = (val << (64 - PACKED_Y_LENGTH) >> (64 - PACKED_Y_LENGTH)) as i32; @@ -311,7 +311,7 @@ impl McBufReadable for BlockPos { } impl McBufReadable for GlobalPos { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(GlobalPos { dimension: ResourceLocation::read_from(buf)?, pos: BlockPos::read_from(buf)?, @@ -320,7 +320,7 @@ impl McBufReadable for GlobalPos { } impl McBufReadable for ChunkSectionPos { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let long = i64::read_from(buf)?; Ok(ChunkSectionPos { x: (long >> 42) as i32, @@ -361,8 +361,6 @@ impl McBufWritable for ChunkSectionPos { #[cfg(test)] mod tests { - use std::io::Cursor; - use super::*; #[test] @@ -403,10 +401,10 @@ mod tests { #[test] fn test_read_blockpos_from() { - let mut buf = Cursor::new(Vec::new()); + let mut buf = Vec::new(); 13743895338965u64.write_into(&mut buf).unwrap(); - buf.set_position(0); - let block_pos = BlockPos::read_from(&mut buf).unwrap(); + let buf = &mut &buf[..]; + let block_pos = BlockPos::read_from(buf).unwrap(); assert_eq!(block_pos, BlockPos::new(49, -43, -3)); } } diff --git a/azalea-core/src/resource_location.rs b/azalea-core/src/resource_location.rs index 4c0764e5..5f8dcea1 100755 --- a/azalea-core/src/resource_location.rs +++ b/azalea-core/src/resource_location.rs @@ -1,7 +1,7 @@ //! A resource, like minecraft:stone use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Hash, Clone, PartialEq, Eq)] pub struct ResourceLocation { @@ -46,7 +46,7 @@ impl std::fmt::Debug for ResourceLocation { } impl McBufReadable for ResourceLocation { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let location_string = String::read_from(buf)?; ResourceLocation::new(&location_string) } @@ -59,8 +59,6 @@ impl McBufWritable for ResourceLocation { #[cfg(test)] mod tests { - use std::io::Cursor; - use super::*; #[test] @@ -96,7 +94,7 @@ mod tests { .write_into(&mut buf) .unwrap(); - let mut buf = Cursor::new(buf); + let mut buf = &mut &buf[..]; assert_eq!( ResourceLocation::read_from(&mut buf).unwrap(), diff --git a/azalea-core/src/slot.rs b/azalea-core/src/slot.rs index 38abcf61..d60c7390 100644 --- a/azalea-core/src/slot.rs +++ b/azalea-core/src/slot.rs @@ -1,7 +1,7 @@ // TODO: have an azalea-inventory or azalea-container crate and put this there use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Debug, Clone)] pub enum Slot { @@ -18,7 +18,7 @@ pub struct SlotData { } impl McBufReadable for Slot { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let present = bool::read_from(buf)?; if !present { return Ok(Slot::Empty); diff --git a/azalea-nbt/benches/my_benchmark.rs b/azalea-nbt/benches/my_benchmark.rs index ed963fb1..2e4efa97 100755 --- a/azalea-nbt/benches/my_benchmark.rs +++ b/azalea-nbt/benches/my_benchmark.rs @@ -1,25 +1,26 @@ use azalea_nbt::Tag; -use criterion::{criterion_group, criterion_main, Criterion, Throughput}; +use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput}; use flate2::read::GzDecoder; use std::{ fs::File, - io::{self, Read, Seek, SeekFrom}, + io::{self, Cursor, Read}, }; fn bench_serialize(filename: &str, c: &mut Criterion) { let mut file = File::open(filename).unwrap(); let mut contents = Vec::new(); file.read_to_end(&mut contents).unwrap(); - let mut src = std::io::Cursor::new(&contents[..]); + let mut src = &contents[..]; // decode the original src so most of the time isn't spent on unzipping let mut decoded_src_decoder = GzDecoder::new(&mut src); let mut decoded_src = Vec::new(); decoded_src_decoder.read_to_end(&mut decoded_src).unwrap(); - let mut decoded_src_stream = std::io::Cursor::new(decoded_src.clone()); - file.seek(SeekFrom::Start(0)).unwrap(); + let mut decoded_src_stream = Cursor::new(&decoded_src[..]); + let nbt = Tag::read(&mut decoded_src_stream).unwrap(); + decoded_src_stream.set_position(0); let mut group = c.benchmark_group(filename); @@ -27,9 +28,8 @@ fn bench_serialize(filename: &str, c: &mut Criterion) { group.bench_function("Decode", |b| { b.iter(|| { - let mut owned_decoded_src_stream = decoded_src_stream.clone(); - owned_decoded_src_stream.seek(SeekFrom::Start(0)).unwrap(); - Tag::read(&mut owned_decoded_src_stream).unwrap(); + black_box(Tag::read(&mut decoded_src_stream).unwrap()); + decoded_src_stream.set_position(0); }) }); diff --git a/azalea-nbt/src/decode.rs b/azalea-nbt/src/decode.rs index 2ab337fc..8a1dfab5 100755 --- a/azalea-nbt/src/decode.rs +++ b/azalea-nbt/src/decode.rs @@ -4,20 +4,31 @@ use ahash::AHashMap; use azalea_buf::{BufReadError, McBufReadable}; use byteorder::{ReadBytesExt, BE}; use flate2::read::{GzDecoder, ZlibDecoder}; +use std::io::Cursor; use std::io::{BufRead, Read}; #[inline] -fn read_string(stream: &mut impl Read) -> Result { - let length = stream.read_u16::()?; +fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8], Error> { + if length > buf.get_ref().len() { + return Err(Error::UnexpectedEof); + } + let initial_position = buf.position() as usize; + buf.set_position(buf.position() + length as u64); + let data = &buf.get_ref()[initial_position..initial_position + length]; + Ok(data) +} - let mut buf = vec![0; length as usize]; - stream.read_exact(&mut buf)?; - Ok(String::from_utf8(buf)?) +#[inline] +fn read_string(stream: &mut Cursor<&[u8]>) -> Result { + let length = stream.read_u16::()? as usize; + + let buf = read_bytes(stream, length)?; + Ok(std::str::from_utf8(buf)?.to_string()) } impl Tag { #[inline] - fn read_known(stream: &mut impl Read, id: u8) -> Result { + fn read_known(stream: &mut Cursor<&[u8]>, id: u8) -> Result { Ok(match id { // Signifies the end of a TAG_Compound. It is only ever used inside // a TAG_Compound, and is not named despite being in a TAG_Compound @@ -39,9 +50,8 @@ impl Tag { // A length-prefixed array of signed bytes. The prefix is a signed // integer (thus 4 bytes) 7 => { - let length = stream.read_u32::()?; - let mut bytes = vec![0; length as usize]; - stream.read_exact(&mut bytes)?; + let length = stream.read_u32::()? as usize; + let bytes = read_bytes(stream, length)?.to_vec(); Tag::ByteArray(bytes) } // A length-prefixed modified UTF-8 string. The prefix is an @@ -58,8 +68,8 @@ impl Tag { // parsers should accept any type if the length is <= 0). 9 => { let type_id = stream.read_u8()?; - let length = stream.read_i32::()?; - let mut list = Vec::with_capacity(length as usize); + let length = stream.read_u32::()?; + let mut list = Vec::new(); for _ in 0..length { list.push(Tag::read_known(stream, type_id)?); } @@ -84,7 +94,10 @@ impl Tag { // signed integer (thus 4 bytes) and indicates the number of 4 byte // integers. 11 => { - let length = stream.read_u32::()?; + let length = stream.read_u32::()? as usize; + if length * 4 > stream.get_ref().len() { + return Err(Error::UnexpectedEof); + } let mut ints = Vec::with_capacity(length as usize); for _ in 0..length { ints.push(stream.read_i32::()?); @@ -94,7 +107,10 @@ impl Tag { // A length-prefixed array of signed longs. The prefix is a signed // integer (thus 4 bytes) and indicates the number of 8 byte longs. 12 => { - let length = stream.read_u32::()?; + let length = stream.read_u32::()? as usize; + if length * 8 > stream.get_ref().len() { + return Err(Error::UnexpectedEof); + } let mut longs = Vec::with_capacity(length as usize); for _ in 0..length { longs.push(stream.read_i64::()?); @@ -105,7 +121,7 @@ impl Tag { }) } - pub fn read(stream: &mut impl Read) -> Result { + pub fn read(stream: &mut Cursor<&[u8]>) -> Result { // default to compound tag // the parent compound only ever has one item @@ -123,17 +139,21 @@ impl Tag { pub fn read_zlib(stream: &mut impl BufRead) -> Result { let mut gz = ZlibDecoder::new(stream); - Tag::read(&mut gz) + let mut buf = Vec::new(); + gz.read_to_end(&mut buf)?; + Tag::read(&mut Cursor::new(&buf)) } - pub fn read_gzip(stream: &mut impl Read) -> Result { + pub fn read_gzip(stream: &mut Cursor>) -> Result { let mut gz = GzDecoder::new(stream); - Tag::read(&mut gz) + let mut buf = Vec::new(); + gz.read_to_end(&mut buf)?; + Tag::read(&mut Cursor::new(&buf)) } } impl McBufReadable for Tag { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(Tag::read(buf)?) } } diff --git a/azalea-nbt/src/error.rs b/azalea-nbt/src/error.rs index ef4a9e9f..308c74c8 100755 --- a/azalea-nbt/src/error.rs +++ b/azalea-nbt/src/error.rs @@ -3,7 +3,8 @@ pub enum Error { InvalidTagType(u8), InvalidTag, WriteError(std::io::Error), - Utf8Error(std::string::FromUtf8Error), + Utf8Error(std::str::Utf8Error), + UnexpectedEof, } impl std::fmt::Display for Error { @@ -13,6 +14,7 @@ impl std::fmt::Display for Error { Error::InvalidTag => write!(f, "Invalid tag"), Error::WriteError(e) => write!(f, "Write error: {}", e), Error::Utf8Error(e) => write!(f, "Utf8 error: {}", e), + Error::UnexpectedEof => write!(f, "Unexpected EOF"), } } } @@ -22,8 +24,8 @@ impl From for Error { Error::WriteError(e) } } -impl From for Error { - fn from(e: std::string::FromUtf8Error) -> Self { +impl From for Error { + fn from(e: std::str::Utf8Error) -> Self { Error::Utf8Error(e) } } diff --git a/azalea-nbt/src/lib.rs b/azalea-nbt/src/lib.rs index c644cfdc..e20049e0 100755 --- a/azalea-nbt/src/lib.rs +++ b/azalea-nbt/src/lib.rs @@ -8,10 +8,11 @@ pub use tag::Tag; #[cfg(test)] mod tests { + use std::io::Cursor; + use super::*; use ahash::AHashMap; use azalea_buf::{McBufReadable, McBufWritable}; - use std::io::Cursor; #[test] fn mcbuf_nbt() { @@ -25,7 +26,7 @@ mod tests { )])); tag.write_into(&mut buf).unwrap(); - let mut buf = Cursor::new(buf); + let mut buf = Cursor::new(&buf[..]); let result = Tag::read_from(&mut buf).unwrap(); assert_eq!( diff --git a/azalea-nbt/tests/tests.rs b/azalea-nbt/tests/tests.rs index 41a14d1b..43c31590 100755 --- a/azalea-nbt/tests/tests.rs +++ b/azalea-nbt/tests/tests.rs @@ -9,7 +9,9 @@ use std::{ fn test_decode_hello_world() { // read hello_world.nbt let mut file = File::open("tests/hello_world.nbt").unwrap(); - let tag = Tag::read(&mut file).unwrap(); + let mut buf = vec![]; + file.read_to_end(&mut buf).unwrap(); + let tag = Tag::read(&mut Cursor::new(&buf[..])).unwrap(); assert_eq!( tag, Tag::Compound(AHashMap::from_iter(vec![( @@ -28,14 +30,14 @@ fn test_roundtrip_hello_world() { let mut original = Vec::new(); file.read_to_end(&mut original).unwrap(); - let mut original_stream = Cursor::new(original.clone()); + let mut original_stream = Cursor::new(&original[..]); let tag = Tag::read(&mut original_stream).unwrap(); // write hello_world.nbt - let mut result = Cursor::new(Vec::new()); + let mut result = Vec::new(); tag.write(&mut result).unwrap(); - assert_eq!(result.into_inner(), original); + assert_eq!(result, original); } #[test] @@ -45,13 +47,13 @@ fn test_bigtest() { let mut original = Vec::new(); file.read_to_end(&mut original).unwrap(); - let mut original_stream = Cursor::new(original.clone()); + let mut original_stream = Cursor::new(original); let original_tag = Tag::read_gzip(&mut original_stream).unwrap(); let mut result = Vec::new(); original_tag.write(&mut result).unwrap(); - let decoded_tag = Tag::read(&mut Cursor::new(result)).unwrap(); + let decoded_tag = Tag::read(&mut Cursor::new(&result)).unwrap(); assert_eq!(decoded_tag, original_tag); } @@ -83,7 +85,7 @@ fn test_stringtest() { let mut original = Vec::new(); file.read_to_end(&mut original).unwrap(); - let mut original_stream = Cursor::new(original.clone()); + let mut original_stream = Cursor::new(original); let original_tag = Tag::read_gzip(&mut original_stream).unwrap(); assert_eq!(original_tag, correct_tag); @@ -95,13 +97,13 @@ fn test_complex_player() { let mut original = Vec::new(); file.read_to_end(&mut original).unwrap(); - let mut original_stream = Cursor::new(original.clone()); + let mut original_stream = Cursor::new(original); let original_tag = Tag::read_gzip(&mut original_stream).unwrap(); let mut result = Vec::new(); original_tag.write(&mut result).unwrap(); - let decoded_tag = Tag::read(&mut Cursor::new(result)).unwrap(); + let decoded_tag = Tag::read(&mut Cursor::new(&result)).unwrap(); assert_eq!(decoded_tag, original_tag); } @@ -112,13 +114,13 @@ fn test_simple_player() { let mut original = Vec::new(); file.read_to_end(&mut original).unwrap(); - let mut original_stream = Cursor::new(original.clone()); + let mut original_stream = Cursor::new(original); let original_tag = Tag::read_gzip(&mut original_stream).unwrap(); let mut result = Vec::new(); original_tag.write(&mut result).unwrap(); - let decoded_tag = Tag::read(&mut Cursor::new(result)).unwrap(); + let decoded_tag = Tag::read(&mut Cursor::new(&result)).unwrap(); assert_eq!(decoded_tag, original_tag); } diff --git a/azalea-protocol/azalea-protocol-macros/src/lib.rs b/azalea-protocol/azalea-protocol-macros/src/lib.rs index ecdabbca..b7e85435 100644 --- a/azalea-protocol/azalea-protocol-macros/src/lib.rs +++ b/azalea-protocol/azalea-protocol-macros/src/lib.rs @@ -30,7 +30,7 @@ fn as_packet_derive(input: TokenStream, state: proc_macro2::TokenStream) -> Toke } pub fn read( - buf: &mut impl std::io::Read, + buf: &mut std::io::Cursor<&[u8]>, ) -> Result<#state, azalea_buf::BufReadError> { use azalea_buf::McBufReadable; Ok(Self::read_from(buf)?.get()) @@ -223,7 +223,7 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream { #id => { let data = #module::#name::read(buf).map_err(|e| crate::read::ReadPacketError::Parse { source: e, packet_id: #id, packet_name: #name_litstr.to_string() })?; let mut leftover = Vec::new(); - let _ = buf.read_to_end(&mut leftover); + let _ = std::io::Read::read_to_end(buf, &mut leftover); if !leftover.is_empty() { return Err(crate::read::ReadPacketError::LeftoverData { packet_name: #name_litstr.to_string(), data: leftover }); } @@ -250,9 +250,10 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream { #[cfg(debug_assertions)] { let mut leftover = Vec::new(); - let _ = buf.read_to_end(&mut leftover); + let _ = std::io::Read::read_to_end(buf, &mut leftover); if !leftover.is_empty() { return Err(crate::read::ReadPacketError::LeftoverData { packet_name: #name_litstr.to_string(), data: leftover }); + } } data @@ -312,7 +313,7 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream { /// Read a packet by its id, ConnectionProtocol, and flow fn read( id: u32, - buf: &mut impl std::io::Read, + buf: &mut std::io::Cursor<&[u8]>, ) -> Result<#serverbound_state_name, crate::read::ReadPacketError> where Self: Sized, @@ -343,7 +344,7 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream { /// Read a packet by its id, ConnectionProtocol, and flow fn read( id: u32, - buf: &mut impl std::io::Read, + buf: &mut std::io::Cursor<&[u8]>, ) -> Result<#clientbound_state_name, crate::read::ReadPacketError> where Self: Sized, diff --git a/azalea-protocol/src/connect.rs b/azalea-protocol/src/connect.rs old mode 100755 new mode 100644 index 3fdcecd3..bd55e406 --- a/azalea-protocol/src/connect.rs +++ b/azalea-protocol/src/connect.rs @@ -9,6 +9,7 @@ use crate::read::{read_packet, ReadPacketError}; use crate::write::write_packet; use crate::ServerIpAddress; use azalea_crypto::{Aes128CfbDec, Aes128CfbEnc}; +use bytes::BytesMut; use std::fmt::Debug; use std::marker::PhantomData; use thiserror::Error; @@ -17,6 +18,7 @@ use tokio::net::TcpStream; pub struct ReadConnection { pub read_stream: OwnedReadHalf, + buffer: BytesMut, pub compression_threshold: Option, pub dec_cipher: Option, _reading: PhantomData, @@ -41,6 +43,7 @@ where pub async fn read(&mut self) -> Result { read_packet::( &mut self.read_stream, + &mut self.buffer, self.compression_threshold, &mut self.dec_cipher, ) @@ -104,6 +107,7 @@ impl Connection { Ok(Connection { reader: ReadConnection { read_stream, + buffer: BytesMut::new(), compression_threshold: None, dec_cipher: None, _reading: PhantomData, @@ -165,6 +169,7 @@ where Connection { reader: ReadConnection { read_stream: connection.reader.read_stream, + buffer: connection.reader.buffer, compression_threshold: connection.reader.compression_threshold, dec_cipher: connection.reader.dec_cipher, _reading: PhantomData, diff --git a/azalea-protocol/src/lib.rs b/azalea-protocol/src/lib.rs index 9fff59f8..4da2ba90 100755 --- a/azalea-protocol/src/lib.rs +++ b/azalea-protocol/src/lib.rs @@ -52,6 +52,8 @@ pub async fn connect(address: ServerAddress) -> Result<(), Box(&mut stream, None, &mut None) - .await - .unwrap(); + let mut stream = Cursor::new(stream); + + let _ = read_packet::( + &mut stream, + &mut BytesMut::new(), + None, + &mut None, + ) + .await + .unwrap(); } } diff --git a/azalea-protocol/src/packets/game/clientbound_boss_event_packet.rs b/azalea-protocol/src/packets/game/clientbound_boss_event_packet.rs index ed7647e9..3bcf10d2 100644 --- a/azalea-protocol/src/packets/game/clientbound_boss_event_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_boss_event_packet.rs @@ -1,10 +1,10 @@ -use std::io::{Read, Write}; - use azalea_buf::{ BufReadError, McBuf, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable, }; use azalea_chat::component::Component; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::Cursor; +use std::io::Write; use uuid::Uuid; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] @@ -24,7 +24,7 @@ pub enum Operation { } impl McBufReadable for Operation { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let operation_id = u32::var_read_from(buf)?; Ok(match operation_id { 0 => Operation::Add(AddOperation::read_from(buf)?), @@ -115,7 +115,7 @@ pub struct Properties { } impl McBufReadable for Properties { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; Ok(Self { darken_screen: byte & 1 != 0, diff --git a/azalea-protocol/src/packets/game/clientbound_command_suggestions_packet.rs b/azalea-protocol/src/packets/game/clientbound_command_suggestions_packet.rs index 42c5580f..c6f426a9 100644 --- a/azalea-protocol/src/packets/game/clientbound_command_suggestions_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_command_suggestions_packet.rs @@ -6,7 +6,7 @@ use azalea_buf::{ McBufWritable, }; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, ClientboundGamePacket)] pub struct ClientboundCommandSuggestionsPacket { @@ -16,7 +16,7 @@ pub struct ClientboundCommandSuggestionsPacket { } impl McBufReadable for ClientboundCommandSuggestionsPacket { - fn read_from(_buf: &mut impl Read) -> Result { + fn read_from(_buf: &mut Cursor<&[u8]>) -> Result { // let id = u32::var_read_from(buf)?; // let start = u32::var_read_from(buf)? as usize; // let length = u32::var_read_from(buf)? as usize; diff --git a/azalea-protocol/src/packets/game/clientbound_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_commands_packet.rs index e18cf52b..2505d2d9 100644 --- a/azalea-protocol/src/packets/game/clientbound_commands_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_commands_packet.rs @@ -5,7 +5,8 @@ use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::ResourceLocation; use azalea_protocol_macros::ClientboundGamePacket; use log::warn; -use std::io::{Read, Write}; +use std::io::Cursor; +use std::io::Write; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundCommandsPacket { @@ -28,7 +29,7 @@ pub struct BrigadierNumber { max: Option, } impl McBufReadable for BrigadierNumber { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let flags = u8::read_from(buf)?; let min = if flags & 0x01 != 0 { Some(T::read_from(buf)?) @@ -127,7 +128,7 @@ pub enum BrigadierParser { } impl McBufReadable for BrigadierParser { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let parser_type = u32::var_read_from(buf)?; match parser_type { @@ -203,7 +204,7 @@ impl McBufReadable for BrigadierParser { // TODO: BrigadierNodeStub should have more stuff impl McBufReadable for BrigadierNodeStub { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let flags = u8::read_from(buf)?; if flags > 31 { warn!( diff --git a/azalea-protocol/src/packets/game/clientbound_explode_packet.rs b/azalea-protocol/src/packets/game/clientbound_explode_packet.rs index 97f58782..10a9e9a9 100644 --- a/azalea-protocol/src/packets/game/clientbound_explode_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_explode_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable}; use azalea_core::BlockPos; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, PartialEq, ClientboundGamePacket)] pub struct ClientboundExplodePacket { @@ -16,7 +16,7 @@ pub struct ClientboundExplodePacket { } impl McBufReadable for ClientboundExplodePacket { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let x = f32::read_from(buf)?; let y = f32::read_from(buf)?; let z = f32::read_from(buf)?; @@ -112,7 +112,7 @@ mod tests { }; let mut buf = Vec::new(); packet.write_into(&mut buf).unwrap(); - let packet2 = ClientboundExplodePacket::read_from(&mut buf.as_slice()).unwrap(); + let packet2 = ClientboundExplodePacket::read_from(&mut Cursor::new(&buf)).unwrap(); assert_eq!(packet, packet2); } } diff --git a/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs b/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs index fdde6ec9..705a7540 100644 --- a/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufWritable}; use azalea_core::ParticleData; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, ClientboundGamePacket)] pub struct ClientboundLevelParticlesPacket { @@ -20,7 +20,7 @@ pub struct ClientboundLevelParticlesPacket { } impl McBufReadable for ClientboundLevelParticlesPacket { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let particle_id = u32::var_read_from(buf)?; let override_limiter = bool::read_from(buf)?; let x = f64::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_map_item_data_packet.rs b/azalea-protocol/src/packets/game/clientbound_map_item_data_packet.rs index 6dc4bfe7..4ce71a12 100644 --- a/azalea-protocol/src/packets/game/clientbound_map_item_data_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_map_item_data_packet.rs @@ -1,9 +1,8 @@ -use std::io::{Read, Write}; - use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable}; use azalea_chat::component::Component; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, ClientboundGamePacket)] pub struct ClientboundMapItemDataPacket { @@ -16,7 +15,7 @@ pub struct ClientboundMapItemDataPacket { } impl McBufReadable for ClientboundMapItemDataPacket { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let map_id = u32::var_read_from(buf)?; let scale = u8::read_from(buf)?; let locked = bool::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs index 2196d1c1..192a7bf4 100755 --- a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundPlayerAbilitiesPacket { @@ -20,7 +20,7 @@ pub struct PlayerAbilitiesFlags { } impl McBufReadable for PlayerAbilitiesFlags { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; Ok(PlayerAbilitiesFlags { invulnerable: byte & 1 != 0, diff --git a/azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs index c9476a45..94062d87 100644 --- a/azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs @@ -95,10 +95,10 @@ mod tests { #[test] fn test_chat_type() { - let chat_type_enum = ChatType::read_from(&mut &[0x06][..]).unwrap(); + let chat_type_enum = ChatType::read_from(&mut Cursor::new(&[0x06])).unwrap(); assert_eq!(chat_type_enum, ChatType::EmoteCommand); assert_eq!( - ChatType::read_from(&mut &[0x07][..]).unwrap(), + ChatType::read_from(&mut Cursor::new(&[0x07])).unwrap(), ChatType::Chat ); } diff --git a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs index 8fb2d644..845eed30 100644 --- a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs @@ -3,7 +3,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_chat::component::Component; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use uuid::Uuid; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] @@ -65,7 +65,7 @@ pub struct RemovePlayer { } impl McBufReadable for Action { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let id = u8::read_from(buf)?; Ok(match id { 0 => Action::AddPlayer(Vec::::read_from(buf)?), diff --git a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs index 842fc258..03a2658e 100644 --- a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundPlayerPositionPacket { @@ -28,7 +28,7 @@ pub struct RelativeArguments { } impl McBufReadable for RelativeArguments { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; Ok(RelativeArguments { x: byte & 0b1 != 0, diff --git a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs index 4e19a114..b6ac6f3b 100644 --- a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs @@ -3,6 +3,7 @@ use azalea_buf::{ }; use azalea_core::ResourceLocation; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, ClientboundGamePacket)] pub struct ClientboundRecipePacket { @@ -12,7 +13,7 @@ pub struct ClientboundRecipePacket { } impl McBufWritable for ClientboundRecipePacket { - fn write_into(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> { + fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { match self.action { State::Init { .. } => 0, State::Add => 1, @@ -28,7 +29,7 @@ impl McBufWritable for ClientboundRecipePacket { } } impl McBufReadable for ClientboundRecipePacket { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let action_id = u32::var_read_from(buf)?; let settings = RecipeBookSettings::read_from(buf)?; let recipes = Vec::::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs index 3f41b3c2..357a30f6 100644 --- a/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs @@ -2,7 +2,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable}; use azalea_core::{ChunkSectionBlockPos, ChunkSectionPos}; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundSectionBlocksUpdatePacket { @@ -18,7 +18,7 @@ pub struct BlockStateWithPosition { } impl McBufReadable for BlockStateWithPosition { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let data = u64::var_read_from(buf)?; let position_part = data & 4095; let state = (data >> 12) as u32; diff --git a/azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs index 9398fb69..315f1590 100644 --- a/azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs @@ -1,8 +1,8 @@ use azalea_buf::{BufReadError, McBuf}; +use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::Slot; use azalea_protocol_macros::ClientboundGamePacket; - -use azalea_buf::{McBufReadable, McBufWritable}; +use std::io::Cursor; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundSetEquipmentPacket { @@ -17,7 +17,7 @@ pub struct EquipmentSlots { } impl McBufReadable for EquipmentSlots { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let mut slots = vec![]; loop { diff --git a/azalea-protocol/src/packets/game/clientbound_set_objective_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_objective_packet.rs index a9c1c859..0e7e334d 100644 --- a/azalea-protocol/src/packets/game/clientbound_set_objective_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_set_objective_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable}; use azalea_chat::component::Component; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundSetObjectivePacket { @@ -17,7 +17,7 @@ pub enum Method { } impl McBufReadable for Method { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(match u8::read_from(buf)? { 0 => Method::Add(DisplayInfo::read_from(buf)?), 1 => Method::Remove, diff --git a/azalea-protocol/src/packets/game/clientbound_set_player_team_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_player_team_packet.rs index fe5a75f8..a0754ddd 100644 --- a/azalea-protocol/src/packets/game/clientbound_set_player_team_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_set_player_team_packet.rs @@ -1,8 +1,7 @@ -use std::io::{Read, Write}; - use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable}; use azalea_chat::{component::Component, style::ChatFormatting}; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundSetPlayerTeamPacket { @@ -20,7 +19,7 @@ pub enum Method { } impl McBufReadable for Method { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { Ok(match u8::read_from(buf)? { 0 => Method::Add((Parameters::read_from(buf)?, PlayerList::read_from(buf)?)), 1 => Method::Remove, diff --git a/azalea-protocol/src/packets/game/clientbound_set_score_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_score_packet.rs index ac1e0bf3..7d055a14 100644 --- a/azalea-protocol/src/packets/game/clientbound_set_score_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_set_score_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable}; use azalea_protocol_macros::ClientboundGamePacket; use std::{ - io::{Read, Write}, + io::{Cursor, Write}, ops::Not, }; @@ -13,7 +13,7 @@ pub struct ClientboundSetScorePacket { } impl McBufReadable for ClientboundSetScorePacket { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let owner = String::read_from(buf)?; let method_id = u32::var_read_from(buf)?; let objective_name = String::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_stop_sound_packet.rs b/azalea-protocol/src/packets/game/clientbound_stop_sound_packet.rs index ee650afb..e0e5db05 100644 --- a/azalea-protocol/src/packets/game/clientbound_stop_sound_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_stop_sound_packet.rs @@ -1,8 +1,7 @@ -use std::io::{Read, Write}; - use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; use azalea_core::ResourceLocation; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::{Cursor, Write}; use super::clientbound_sound_packet::SoundSource; @@ -13,7 +12,7 @@ pub struct ClientboundStopSoundPacket { } impl McBufReadable for ClientboundStopSoundPacket { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; let source = if byte & 1 != 0 { Some(SoundSource::read_from(buf)?) diff --git a/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs index f7adcafa..eb52e133 100644 --- a/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs @@ -3,6 +3,7 @@ use azalea_chat::component::Component; use azalea_core::{ResourceLocation, Slot}; use azalea_protocol_macros::ClientboundGamePacket; use std::collections::HashMap; +use std::io::Cursor; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundUpdateAdvancementsPacket { @@ -63,7 +64,7 @@ impl azalea_buf::McBufWritable for DisplayInfo { } } impl azalea_buf::McBufReadable for DisplayInfo { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let title = azalea_buf::McBufReadable::read_from(buf)?; let description = azalea_buf::McBufReadable::read_from(buf)?; let icon = azalea_buf::McBufReadable::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs index 5c03d11f..bcccdc3f 100644 --- a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs @@ -2,7 +2,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::ResourceLocation; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use uuid::Uuid; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] @@ -34,7 +34,7 @@ enum Operation { } impl McBufReadable for Operation { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { match u8::read_from(buf)? { 0 => Ok(Operation::Addition), 1 => Ok(Operation::MultiplyBase), diff --git a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs index 8d8ef32b..db31ef78 100644 --- a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs @@ -3,7 +3,7 @@ use azalea_buf::{ }; use azalea_core::{ResourceLocation, Slot}; use azalea_protocol_macros::ClientboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundUpdateRecipesPacket { @@ -47,7 +47,7 @@ impl McBufWritable for ShapedRecipe { } } impl McBufReadable for ShapedRecipe { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let width = u32::var_read_from(buf)?.try_into().unwrap(); let height = u32::var_read_from(buf)?.try_into().unwrap(); let group = String::read_from(buf)?; @@ -127,7 +127,7 @@ impl McBufWritable for Recipe { } impl McBufReadable for Recipe { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let recipe_type = ResourceLocation::read_from(buf)?; let identifier = ResourceLocation::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs index 8f5cd04e..3e6e413a 100755 --- a/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs +++ b/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs @@ -2,11 +2,9 @@ use azalea_buf::{BufReadError, McBuf, McBufVarReadable, McBufVarWritable}; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::ResourceLocation; use azalea_protocol_macros::ClientboundGamePacket; +use std::io::Cursor; use std::ops::Deref; -use std::{ - collections::HashMap, - io::{Read, Write}, -}; +use std::{collections::HashMap, io::Write}; #[derive(Clone, Debug, McBuf, ClientboundGamePacket)] pub struct ClientboundUpdateTagsPacket { @@ -23,7 +21,7 @@ pub struct Tags { pub struct TagMap(HashMap>); impl McBufReadable for TagMap { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let length = u32::var_read_from(buf)? as usize; let mut data = HashMap::with_capacity(length); for _ in 0..length { @@ -51,7 +49,7 @@ impl McBufWritable for TagMap { } } impl McBufReadable for Tags { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let name = ResourceLocation::read_from(buf)?; let elements = Vec::::var_read_from(buf)?; Ok(Tags { name, elements }) diff --git a/azalea-protocol/src/packets/game/serverbound_interact_packet.rs b/azalea-protocol/src/packets/game/serverbound_interact_packet.rs index f40ce406..1904accf 100644 --- a/azalea-protocol/src/packets/game/serverbound_interact_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_interact_packet.rs @@ -2,7 +2,7 @@ use crate::packets::BufReadError; use azalea_buf::{McBuf, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable}; use azalea_core::Vec3; use azalea_protocol_macros::ServerboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ServerboundGamePacket)] pub struct ServerboundInteractPacket { @@ -48,7 +48,7 @@ impl McBufWritable for ActionType { } impl McBufReadable for ActionType { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let action_type = u32::var_read_from(buf)?; match action_type { 0 => { diff --git a/azalea-protocol/src/packets/game/serverbound_player_abilities_packet.rs b/azalea-protocol/src/packets/game/serverbound_player_abilities_packet.rs index 3d9cd930..ab1ae9a0 100644 --- a/azalea-protocol/src/packets/game/serverbound_player_abilities_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_player_abilities_packet.rs @@ -1,6 +1,7 @@ use crate::packets::BufReadError; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_protocol_macros::ServerboundGamePacket; +use std::io::Cursor; #[derive(Clone, Debug, ServerboundGamePacket)] pub struct ServerboundPlayerAbilitiesPacket { @@ -8,7 +9,7 @@ pub struct ServerboundPlayerAbilitiesPacket { } impl McBufReadable for ServerboundPlayerAbilitiesPacket { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; Ok(Self { is_flying: byte & 2 != 0, diff --git a/azalea-protocol/src/packets/game/serverbound_player_input_packet.rs b/azalea-protocol/src/packets/game/serverbound_player_input_packet.rs index ab0a5df0..30d3c3ae 100644 --- a/azalea-protocol/src/packets/game/serverbound_player_input_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_player_input_packet.rs @@ -1,3 +1,5 @@ +use std::io::Cursor; + use azalea_buf::BufReadError; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_protocol_macros::ServerboundGamePacket; @@ -11,7 +13,7 @@ pub struct ServerboundPlayerInputPacket { } impl McBufReadable for ServerboundPlayerInputPacket { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let xxa = f32::read_from(buf)?; let zza = f32::read_from(buf)?; let byte = u8::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/serverbound_seen_advancements_packet.rs b/azalea-protocol/src/packets/game/serverbound_seen_advancements_packet.rs index 82e90689..5a9b0e48 100644 --- a/azalea-protocol/src/packets/game/serverbound_seen_advancements_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_seen_advancements_packet.rs @@ -2,6 +2,7 @@ use crate::packets::BufReadError; use azalea_buf::{McBuf, McBufReadable, McBufWritable}; use azalea_core::ResourceLocation; use azalea_protocol_macros::ServerboundGamePacket; +use std::io::Cursor; #[derive(Clone, Debug, ServerboundGamePacket)] pub struct ServerboundSeenAdvancementsPacket { @@ -16,7 +17,7 @@ pub enum Action { } impl McBufReadable for ServerboundSeenAdvancementsPacket { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let action = Action::read_from(buf)?; let tab = if action == Action::OpenedTab { Some(ResourceLocation::read_from(buf)?) diff --git a/azalea-protocol/src/packets/game/serverbound_set_command_block_packet.rs b/azalea-protocol/src/packets/game/serverbound_set_command_block_packet.rs index 66bbb91a..7edb9719 100644 --- a/azalea-protocol/src/packets/game/serverbound_set_command_block_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_set_command_block_packet.rs @@ -2,6 +2,7 @@ use crate::packets::McBufWritable; use azalea_buf::{BufReadError, McBuf, McBufReadable}; use azalea_core::BlockPos; use azalea_protocol_macros::ServerboundGamePacket; +use std::io::Cursor; #[derive(Clone, Debug, ServerboundGamePacket)] pub struct ServerboundSetCommandBlockPacket { @@ -22,7 +23,7 @@ pub enum Mode { } impl McBufReadable for ServerboundSetCommandBlockPacket { - fn read_from(buf: &mut impl std::io::Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let pos = BlockPos::read_from(buf)?; let command = String::read_from(buf)?; let mode = Mode::read_from(buf)?; diff --git a/azalea-protocol/src/packets/game/serverbound_set_jigsaw_block_packet.rs b/azalea-protocol/src/packets/game/serverbound_set_jigsaw_block_packet.rs index 94653bc7..78f77754 100644 --- a/azalea-protocol/src/packets/game/serverbound_set_jigsaw_block_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_set_jigsaw_block_packet.rs @@ -5,7 +5,8 @@ use azalea_buf::McBufReadable; use azalea_core::BlockPos; use azalea_core::ResourceLocation; use azalea_protocol_macros::ServerboundGamePacket; -use std::io::{Read, Write}; +use std::io::Cursor; +use std::io::Write; #[derive(Clone, Debug, McBuf, ServerboundGamePacket)] pub struct ServerboundSetJigsawBlockPacket { @@ -23,7 +24,7 @@ pub enum JointType { } impl McBufReadable for JointType { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let name = String::read_from(buf)?; match name.as_str() { "rollable" => Ok(JointType::Rollable), diff --git a/azalea-protocol/src/packets/game/serverbound_set_structure_block_packet.rs b/azalea-protocol/src/packets/game/serverbound_set_structure_block_packet.rs index 0851857f..901d3f89 100644 --- a/azalea-protocol/src/packets/game/serverbound_set_structure_block_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_set_structure_block_packet.rs @@ -3,7 +3,7 @@ use azalea_buf::McBuf; use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::BlockPos; use azalea_protocol_macros::ServerboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ServerboundGamePacket)] pub struct ServerboundSetStructureBlockPacket { @@ -68,7 +68,7 @@ pub struct Flags { } impl McBufReadable for Flags { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let byte = u8::read_from(buf)?; Ok(Self { ignore_entities: byte & 1 != 0, diff --git a/azalea-protocol/src/packets/game/serverbound_use_item_on_packet.rs b/azalea-protocol/src/packets/game/serverbound_use_item_on_packet.rs index ab3fa137..ded977aa 100644 --- a/azalea-protocol/src/packets/game/serverbound_use_item_on_packet.rs +++ b/azalea-protocol/src/packets/game/serverbound_use_item_on_packet.rs @@ -2,7 +2,7 @@ use crate::packets::game::serverbound_interact_packet::InteractionHand; use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable}; use azalea_core::{BlockPos, Direction, Vec3}; use azalea_protocol_macros::ServerboundGamePacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, McBuf, ServerboundGamePacket)] pub struct ServerboundUseItemOnPacket { @@ -33,7 +33,7 @@ impl McBufWritable for BlockHitResult { } impl McBufReadable for BlockHitResult { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let block_pos = BlockPos::read_from(buf)?; let direction = Direction::read_from(buf)?; let cursor_x = f32::read_from(buf)?; diff --git a/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs b/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs index 6ecbfb66..6976298a 100755 --- a/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs +++ b/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs @@ -1,31 +1,9 @@ -use super::ClientboundLoginPacket; -use azalea_buf::{BufReadError, McBufVarReadable, McBufVarWritable}; -use std::{ - hash::Hash, - io::{Read, Write}, -}; +use azalea_buf::McBuf; +use azalea_protocol_macros::ClientboundLoginPacket; +use std::hash::Hash; -#[derive(Hash, Clone, Debug)] +#[derive(Hash, Clone, Debug, ClientboundLoginPacket, McBuf)] pub struct ClientboundLoginCompressionPacket { + #[var] pub compression_threshold: i32, } - -impl ClientboundLoginCompressionPacket { - pub fn get(self) -> ClientboundLoginPacket { - ClientboundLoginPacket::LoginCompression(self) - } - - pub fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> { - self.compression_threshold.var_write_into(buf)?; - Ok(()) - } - - pub fn read(buf: &mut impl Read) -> Result { - let compression_threshold = i32::var_read_from(buf)?; - - Ok(ClientboundLoginCompressionPacket { - compression_threshold, - } - .get()) - } -} diff --git a/azalea-protocol/src/packets/login/serverbound_hello_packet.rs b/azalea-protocol/src/packets/login/serverbound_hello_packet.rs index 4d94092e..5e1422fb 100755 --- a/azalea-protocol/src/packets/login/serverbound_hello_packet.rs +++ b/azalea-protocol/src/packets/login/serverbound_hello_packet.rs @@ -18,6 +18,8 @@ pub struct ProfilePublicKeyData { #[cfg(test)] mod tests { + use std::io::Cursor; + use super::*; use azalea_buf::{McBufReadable, McBufWritable}; @@ -28,9 +30,9 @@ mod tests { public_key: None, profile_id: Some(Uuid::from_u128(0)), }; - let mut buf = Vec::new(); + let mut buf: Vec = Vec::new(); packet.write_into(&mut buf).unwrap(); - let packet2 = ServerboundHelloPacket::read_from(&mut buf.as_slice()).unwrap(); + let packet2 = ServerboundHelloPacket::read_from(&mut Cursor::new(&buf)).unwrap(); assert_eq!(packet, packet2); } } diff --git a/azalea-protocol/src/packets/login/serverbound_key_packet.rs b/azalea-protocol/src/packets/login/serverbound_key_packet.rs index ba4bcb8a..23b3659b 100644 --- a/azalea-protocol/src/packets/login/serverbound_key_packet.rs +++ b/azalea-protocol/src/packets/login/serverbound_key_packet.rs @@ -1,7 +1,7 @@ use azalea_buf::{BufReadError, McBuf}; use azalea_crypto::SaltSignaturePair; use azalea_protocol_macros::ServerboundLoginPacket; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use azalea_buf::{McBufReadable, McBufWritable}; @@ -18,7 +18,7 @@ pub enum NonceOrSaltSignature { } impl McBufReadable for NonceOrSaltSignature { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let is_nonce = bool::read_from(buf)?; if is_nonce { Ok(NonceOrSaltSignature::Nonce(Vec::::read_from(buf)?)) diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs index 110929a1..f7270b51 100644 --- a/azalea-protocol/src/packets/mod.rs +++ b/azalea-protocol/src/packets/mod.rs @@ -5,7 +5,7 @@ pub mod status; use crate::read::ReadPacketError; use azalea_buf::{BufReadError, McBufVarReadable, McBufVarWritable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; // TODO: rename the packet files to just like clientbound_add_entity instead of clientbound_add_entity_packet @@ -39,13 +39,13 @@ where fn id(&self) -> u32; /// Read a packet by its id, ConnectionProtocol, and flow - fn read(id: u32, buf: &mut impl Read) -> Result; + fn read(id: u32, buf: &mut Cursor<&[u8]>) -> Result; fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>; } impl azalea_buf::McBufReadable for ConnectionProtocol { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let id = i32::var_read_from(buf)?; ConnectionProtocol::from_i32(id).ok_or(BufReadError::UnexpectedEnumVariant { id }) } diff --git a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs index f7a349e2..f8b46b8d 100755 --- a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs +++ b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs @@ -1,14 +1,14 @@ -use super::ClientboundStatusPacket; -use azalea_buf::{BufReadError, McBufReadable}; +use azalea_buf::{BufReadError, McBufReadable, McBufWritable}; use azalea_chat::component::Component; +use azalea_protocol_macros::ClientboundStatusPacket; use serde::Deserialize; use serde_json::Value; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; #[derive(Clone, Debug, Deserialize)] pub struct Version { pub name: Component, - pub protocol: u32, + pub protocol: i32, } #[derive(Clone, Debug, Deserialize)] @@ -26,7 +26,7 @@ pub struct Players { } // the entire packet is just json, which is why it has deserialize -#[derive(Clone, Debug, Deserialize)] +#[derive(Clone, Debug, Deserialize, ClientboundStatusPacket)] pub struct ClientboundStatusResponsePacket { pub description: Component, pub favicon: Option, @@ -34,21 +34,17 @@ pub struct ClientboundStatusResponsePacket { pub version: Version, } -impl ClientboundStatusResponsePacket { - pub fn get(self) -> ClientboundStatusPacket { - ClientboundStatusPacket::StatusResponse(self) - } - - pub fn write(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> { - Ok(()) - } - - pub fn read(buf: &mut impl Read) -> Result { +impl McBufReadable for ClientboundStatusResponsePacket { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let status_string = String::read_from(buf)?; let status_json: Value = serde_json::from_str(status_string.as_str())?; - let packet = ClientboundStatusResponsePacket::deserialize(status_json)?.get(); - - Ok(packet) + Ok(ClientboundStatusResponsePacket::deserialize(status_json)?) + } +} + +impl McBufWritable for ClientboundStatusResponsePacket { + fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> { + todo!() } } diff --git a/azalea-protocol/src/read.rs b/azalea-protocol/src/read.rs old mode 100755 new mode 100644 index 8a2aaf7d..eceede9d --- a/azalea-protocol/src/read.rs +++ b/azalea-protocol/src/read.rs @@ -1,9 +1,12 @@ use crate::packets::ProtocolPacket; +use azalea_buf::BufReadError; use azalea_buf::McBufVarReadable; -use azalea_buf::{read_varint_async, BufReadError}; use azalea_crypto::Aes128CfbDec; +use bytes::Buf; +use bytes::BytesMut; use flate2::read::ZlibDecoder; use log::{log_enabled, trace}; +use std::io::Cursor; use std::{ cell::Cell, io::Read, @@ -52,34 +55,82 @@ pub enum FrameSplitterError { source: std::io::Error, }, #[error("Packet is longer than {max} bytes (is {size})")] - BadLength { max: u32, size: u32 }, + BadLength { max: usize, size: usize }, + #[error("Connection reset by peer")] + ConnectionReset, + #[error("Connection closed")] + ConnectionClosed, } -async fn frame_splitter(mut stream: &mut R) -> Result, FrameSplitterError> -where - R: AsyncRead + std::marker::Unpin + std::marker::Send, -{ +/// Read a length, then read that amount of bytes from BytesMut. If there's not +/// enough data, return None +fn parse_frame(buffer: &mut BytesMut) -> Result { + // copy the buffer first and read from the copy, then once we make sure + // the packet is all good we read it fully + let mut buffer_copy = Cursor::new(&buffer[..]); // Packet Length - let length = read_varint_async(&mut stream).await? as u32; + let length = match u32::var_read_from(&mut buffer_copy) { + Ok(length) => length as usize, + Err(err) => match err { + BufReadError::Io(io_err) => return Err(FrameSplitterError::Io { source: io_err }), + _ => return Err(err.into()), + }, + }; - // TODO: read individual tcp packets so we don't need this - // https://github.com/tokio-rs/tokio/blob/master/examples/print_each_packet.rs - let max_length: u32 = 2u32.pow(20u32); // 1mb, arbitrary - if length > max_length { - // minecraft *probably* won't send packets bigger than this + if length > buffer_copy.get_ref().len() { return Err(FrameSplitterError::BadLength { - max: max_length, + max: buffer_copy.get_ref().len(), size: length, }); } - let mut buf = vec![0; length as usize]; - stream.read_exact(&mut buf).await?; + // we read from the copy and we know it's legit, so we can take those bytes + // from the real buffer now - Ok(buf) + // the length of the varint that says the length of the whole packet + let varint_length = buffer.len() - buffer_copy.remaining(); + let _ = buffer.split_to(varint_length); + let data = buffer.split_to(length); + + Ok(data) } -fn packet_decoder(stream: &mut impl Read) -> Result { +async fn frame_splitter<'a, R: ?Sized + Sized>( + stream: &mut R, + buffer: &'a mut BytesMut, +) -> Result, FrameSplitterError> +where + R: AsyncRead + std::marker::Unpin + std::marker::Send, +{ + // https://tokio.rs/tokio/tutorial/framing + loop { + let read_frame = parse_frame(buffer); + match read_frame { + Ok(frame) => return Ok(frame.to_vec()), + Err(err) => match err { + FrameSplitterError::BadLength { .. } | FrameSplitterError::Io { .. } => { + // we probably just haven't read enough yet + } + _ => return Err(err), + }, + } + + let read_buf: usize = AsyncReadExt::read_buf(stream, buffer).await?; + if 0 == read_buf { + // The remote closed the connection. For this to be + // a clean shutdown, there should be no data in the + // read buffer. If there is, this means that the + // peer closed the socket while sending a frame. + if buffer.as_ref().is_empty() { + return Err(FrameSplitterError::ConnectionClosed); + } else { + return Err(FrameSplitterError::ConnectionReset); + } + } + } +} + +fn packet_decoder(stream: &mut Cursor<&[u8]>) -> Result { // Packet ID let packet_id = u32::var_read_from(stream).map_err(|e| ReadPacketError::ReadPacketId { source: e })?; @@ -112,7 +163,7 @@ pub enum DecompressionError { } fn compression_decoder( - stream: &mut impl Read, + stream: &mut Cursor<&[u8]>, compression_threshold: u32, ) -> Result, DecompressionError> { // Data Length @@ -120,7 +171,7 @@ fn compression_decoder( if n == 0 { // no data size, no compression let mut buf = vec![]; - stream.read_to_end(&mut buf)?; + std::io::Read::read_to_end(stream, &mut buf)?; return Ok(buf); } @@ -183,6 +234,7 @@ where pub async fn read_packet<'a, P: ProtocolPacket, R>( stream: &'a mut R, + buffer: &mut BytesMut, compression_threshold: Option, cipher: &mut Option, ) -> Result @@ -195,10 +247,10 @@ where stream: &mut Pin::new(stream), }; - let mut buf = frame_splitter(&mut encrypted_stream).await?; + let mut buf = frame_splitter(&mut encrypted_stream, buffer).await?; if let Some(compression_threshold) = compression_threshold { - buf = compression_decoder(&mut buf.as_slice(), compression_threshold)?; + buf = compression_decoder(&mut Cursor::new(&buf[..]), compression_threshold)?; } if log_enabled!(log::Level::Trace) { @@ -213,7 +265,7 @@ where trace!("Reading packet with bytes: {buf_string}"); } - let packet = packet_decoder(&mut buf.as_slice())?; + let packet = packet_decoder(&mut Cursor::new(&buf[..]))?; Ok(packet) } @@ -226,7 +278,7 @@ mod tests { #[tokio::test] async fn test_read_packet() { - let mut buf = Cursor::new(vec![ + let mut buf: Cursor<&[u8]> = Cursor::new(&[ 51, 0, 12, 177, 250, 155, 132, 106, 60, 218, 161, 217, 90, 157, 105, 57, 206, 20, 0, 5, 104, 101, 108, 108, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 116, 123, 34, 101, 120, 116, 114, 97, 34, 58, 91, 123, 34, 99, 111, 108, 111, 114, 34, 58, diff --git a/azalea-world/src/chunk_storage.rs b/azalea-world/src/chunk_storage.rs index 9d81b28f..566b3198 100644 --- a/azalea-world/src/chunk_storage.rs +++ b/azalea-world/src/chunk_storage.rs @@ -7,8 +7,9 @@ use azalea_buf::{McBufReadable, McBufWritable}; use azalea_core::floor_mod; use azalea_core::{BlockPos, ChunkBlockPos, ChunkPos, ChunkSectionBlockPos}; use std::fmt::Debug; +use std::io::Cursor; use std::{ - io::{Read, Write}, + io::Write, ops::{Index, IndexMut}, sync::{Arc, Mutex}, }; @@ -100,7 +101,7 @@ impl ChunkStorage { pub fn replace_with_packet_data( &mut self, pos: &ChunkPos, - data: &mut impl Read, + data: &mut Cursor<&[u8]>, ) -> Result<(), BufReadError> { if !self.in_range(pos) { println!( @@ -137,14 +138,14 @@ impl IndexMut<&ChunkPos> for ChunkStorage { impl Chunk { pub fn read_with_dimension( - buf: &mut impl Read, + buf: &mut Cursor<&[u8]>, data: &Dimension, ) -> Result { Self::read_with_dimension_height(buf, data.height()) } pub fn read_with_dimension_height( - buf: &mut impl Read, + buf: &mut Cursor<&[u8]>, dimension_height: u32, ) -> Result { let section_count = dimension_height / SECTION_HEIGHT; @@ -216,7 +217,7 @@ impl Debug for ChunkStorage { } impl McBufReadable for Section { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let block_count = u16::read_from(buf)?; // this is commented out because the vanilla server is wrong diff --git a/azalea-world/src/entity/data.rs b/azalea-world/src/entity/data.rs index ba8a2157..3fd07ecb 100644 --- a/azalea-world/src/entity/data.rs +++ b/azalea-world/src/entity/data.rs @@ -2,7 +2,7 @@ use azalea_buf::{BufReadError, McBufVarReadable}; use azalea_buf::{McBuf, McBufReadable, McBufWritable}; use azalea_chat::component::Component; use azalea_core::{BlockPos, Direction, GlobalPos, Particle, Slot}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use uuid::Uuid; #[derive(Clone, Debug)] @@ -17,7 +17,7 @@ pub struct EntityDataItem { } impl McBufReadable for EntityMetadata { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let mut metadata = Vec::new(); loop { let index = u8::read_from(buf)?; @@ -74,7 +74,7 @@ pub enum EntityDataValue { } impl McBufReadable for EntityDataValue { - fn read_from(buf: &mut impl Read) -> Result { + fn read_from(buf: &mut Cursor<&[u8]>) -> Result { let data_type = u32::var_read_from(buf)?; Ok(match data_type { 0 => EntityDataValue::Byte(u8::read_from(buf)?), diff --git a/azalea-world/src/lib.rs b/azalea-world/src/lib.rs index 4f51d655..08b7ebf4 100644 --- a/azalea-world/src/lib.rs +++ b/azalea-world/src/lib.rs @@ -14,7 +14,7 @@ pub use chunk_storage::{Chunk, ChunkStorage}; use entity::{EntityData, EntityMut, EntityRef}; pub use entity_storage::EntityStorage; use std::{ - io::Read, + io::Cursor, ops::{Index, IndexMut}, sync::{Arc, Mutex}, }; @@ -47,7 +47,7 @@ impl Dimension { pub fn replace_with_packet_data( &mut self, pos: &ChunkPos, - data: &mut impl Read, + data: &mut Cursor<&[u8]>, ) -> Result<(), BufReadError> { self.chunk_storage.replace_with_packet_data(pos, data) } diff --git a/azalea-world/src/palette.rs b/azalea-world/src/palette.rs index ddb0c587..a467ea93 100644 --- a/azalea-world/src/palette.rs +++ b/azalea-world/src/palette.rs @@ -1,5 +1,5 @@ use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufWritable}; -use std::io::{Read, Write}; +use std::io::{Cursor, Write}; use crate::BitStorage; @@ -33,7 +33,7 @@ impl PalettedContainer { } pub fn read_with_type( - buf: &mut impl Read, + buf: &mut Cursor<&[u8]>, container_type: &'static PalettedContainerType, ) -> Result { let bits_per_entry = u8::read_from(buf)?; @@ -256,7 +256,7 @@ impl PaletteType { } } - pub fn read(&self, buf: &mut impl Read) -> Result { + pub fn read(&self, buf: &mut Cursor<&[u8]>) -> Result { Ok(match self { PaletteType::SingleValue => Palette::SingleValue(u32::var_read_from(buf)?), PaletteType::Linear => Palette::Linear(Vec::::var_read_from(buf)?),