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<Vec<u8>>

* wip

* fix all the issues

* fix all tests

* fix nbt benchmark

* fix warnings

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<u32> for BlockState {
 }
 
 impl McBufReadable for BlockState {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let state_id = u32::var_read_from(buf)?;
         Self::try_from(state_id).map_err(|_| BufReadError::UnexpectedEnumVariant {
             id: state_id as i32,

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<Self, azalea_buf::BufReadError> {
+                fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
                     #(#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<Self, azalea_buf::BufReadError>
+                fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError>
                 {
                     let id = azalea_buf::McBufVarReadable::var_read_from(buf)?;
                     match id {

azalea-buf/src/definitions.rs

@@ -2,10 +2,10 @@ use std::ops::Deref;
 
 /// A Vec<u8> that isn't prefixed by a VarInt with the size.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnsizedByteArray(Vec<u8>);
+pub struct UnsizedByteArray(pub Vec<u8>);
 
 impl Deref for UnsizedByteArray {
-    type Target = Vec<u8>;
+    type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
         &self.0

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]);
+        let buf = &mut &vec![0][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 0);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 0);
 
-        let mut buf = Cursor::new(vec![1]);
+        let buf = &mut &vec![1][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 1);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 1);
 
-        let mut buf = Cursor::new(vec![2]);
+        let buf = &mut &vec![2][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 2);
 
-        let mut buf = Cursor::new(vec![127]);
+        let buf = &mut &vec![127][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 127);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 127);
 
-        let mut buf = Cursor::new(vec![128, 1]);
+        let buf = &mut &vec![128, 1][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 128);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 128);
 
-        let mut buf = Cursor::new(vec![255, 1]);
+        let buf = &mut &vec![255, 1][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 255);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 255);
 
-        let mut buf = Cursor::new(vec![221, 199, 1]);
+        let buf = &mut &vec![221, 199, 1][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 25565);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 25565);
 
-        let mut buf = Cursor::new(vec![255, 255, 127]);
+        let buf = &mut &vec![255, 255, 127][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2097151);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 2097151);
 
-        let mut buf = Cursor::new(vec![255, 255, 255, 255, 7]);
+        let buf = &mut &vec![255, 255, 255, 255, 7][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 2147483647);
+        assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647);
 
-        let mut buf = Cursor::new(vec![255, 255, 255, 255, 15]);
+        let buf = &mut &vec![255, 255, 255, 255, 15][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), -1);
+        assert_eq!(i32::var_read_from(buf).unwrap(), -1);
 
-        let mut buf = Cursor::new(vec![128, 128, 128, 128, 8]);
+        let buf = &mut &vec![128, 128, 128, 128, 8][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), -2147483648);
+        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]);
+        let buf = &mut &vec![138, 56, 0, 135, 56, 123][..];
-        assert_eq!(i32::var_read_from(&mut buf).unwrap(), 7178);
+        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 buf = &mut &buf[..];
-        let result = Vec::<String>::read_from(&mut buf).unwrap();
+        let result = Vec::<String>::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::<i32>::var_read_from(&mut buf).unwrap();
+        let result = Vec::<i32>::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::<String, i32>::var_read_from(&mut buf).unwrap();
+        let result = HashMap::<String, i32>::var_read_from(buf).unwrap();
 
         assert_eq!(result, original_map);
     }
 
     #[test]
     fn test_long() {
-        let mut buf = Vec::new();
+        let buf: &mut Vec<u8> = &mut Vec::new();
-        123456u64.write_into(&mut buf).unwrap();
+        123456u64.write_into(buf).unwrap();
 
-        let mut buf = Cursor::new(buf);
+        let buf = &mut &buf[..];
-
+        assert_eq!(u64::read_from(buf).unwrap(), 123456);
-        assert_eq!(u64::read_from(&mut buf).unwrap(), 123456);
     }
 }

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<String, BufReadError> {
+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<String, BufReadError> {
     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<String, Buf
         });
     }
 
-    // this is probably quite inefficient, idk how to do it better
+    let buffer = read_bytes(buf, length as usize)?;
-    let mut string = String::new();
+    let string = std::str::from_utf8(buffer)
-    let mut buffer = vec![0; length as usize];
+        .map_err(|_| BufReadError::InvalidUtf8)?
-    buf.read_exact(&mut buffer)
+        .to_string();
-        .map_err(|_| BufReadError::InvalidUtf8)?;
-    string.push_str(std::str::from_utf8(&buffer).map_err(|_| BufReadError::InvalidUtf8)?);
     if string.len() > 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<String, Buf
 
 // 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, along with the number of bytes read
-pub async fn read_varint_async(
+// pub async fn read_varint_async(
-    reader: &mut (dyn AsyncRead + Unpin + Send),
+//     reader: &mut (dyn AsyncRead + Unpin + Send),
-) -> Result<i32, BufReadError> {
+// ) -> Result<i32, BufReadError> {
-    let mut buffer = [0];
+//     let mut buffer = [0];
-    let mut ans = 0;
+//     let mut ans = 0;
-    for i in 0..5 {
+//     for i in 0..5 {
-        reader.read_exact(&mut buffer).await?;
+//         reader.read_exact(&mut buffer).await?;
-        ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
+//         ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
-        if buffer[0] & 0b1000_0000 == 0 {
+//         if buffer[0] & 0b1000_0000 == 0 {
-            break;
+//             break;
-        }
+//         }
-    }
+//     }
-    Ok(ans)
+//     Ok(ans)
-}
+// }
 
 pub trait McBufReadable
 where
     Self: Sized,
 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError>;
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
 }
 
 pub trait McBufVarReadable
 where
     Self: Sized,
 {
-    fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError>;
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
 }
 
 impl McBufReadable for i32 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i32::<BE>()?)
     }
 }
@@ -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<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         i64::var_read_from(buf).map(|i| i as u64)
     }
 }
 
 impl McBufReadable for UnsizedByteArray {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         // read to end of the buffer
-        let mut bytes = vec![];
+        let data = buf.get_ref()[buf.position() as usize..].to_vec();
-        buf.read_to_end(&mut bytes)
+        buf.set_position((buf.position()) + data.len() as u64);
-            .map_err(|_| BufReadError::CouldNotReadBytes)?;
+        Ok(UnsizedByteArray(data))
-        Ok(bytes.into())
     }
 }
 
 impl<T: McBufReadable + Send> McBufReadable for Vec<T> {
-    default fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<T: McBufReadable + Send> McBufReadable for Vec<T> {
 }
 
 impl<K: McBufReadable + Send + Eq + Hash, V: McBufReadable + Send> McBufReadable for HashMap<K, V> {
-    default fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<K: McBufReadable + Send + Eq + Hash, V: McBufReadable + Send> McBufReadable
 impl<K: McBufReadable + Send + Eq + Hash, V: McBufVarReadable + Send> McBufVarReadable
     for HashMap<K, V>
 {
-    default fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<K: McBufReadable + Send + Eq + Hash, V: McBufVarReadable + Send> McBufVarRe
 }
 
 impl McBufReadable for Vec<u8> {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let length = i32::var_read_from(buf)? as usize;
-        let mut buffer = vec![0; length];
+        read_bytes(buf, length).map(|b| b.to_vec())
-        buf.read_exact(&mut buffer)
-            .map_err(|_| BufReadError::CouldNotReadBytes)?;
-        Ok(buffer)
     }
 }
 
 impl McBufReadable for String {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         read_utf_with_len(buf, MAX_STRING_LENGTH.into())
     }
 }
 
 impl McBufReadable for u32 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(i32::read_from(buf)? as u32)
     }
 }
 
 impl McBufVarReadable for u32 {
-    fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(i32::var_read_from(buf)? as u32)
     }
 }
 
 impl McBufReadable for u16 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         i16::read_from(buf).map(|i| i as u16)
     }
 }
 
 impl McBufReadable for i16 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i16::<BE>()?)
     }
 }
 
 impl McBufVarReadable for u16 {
-    fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(i32::var_read_from(buf)? as u16)
     }
 }
 
 impl<T: McBufVarReadable> McBufVarReadable for Vec<T> {
-    fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<T: McBufVarReadable> McBufVarReadable for Vec<T> {
 }
 
 impl McBufReadable for i64 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i64::<BE>()?)
     }
 }
 
 impl McBufReadable for u64 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         i64::read_from(buf).map(|i| i as u64)
     }
 }
 
 impl McBufReadable for bool {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(u8::read_from(buf)? != 0)
     }
 }
 
 impl McBufReadable for u8 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_u8()?)
     }
 }
 
 impl McBufReadable for i8 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         u8::read_from(buf).map(|i| i as i8)
     }
 }
 
 impl McBufReadable for f32 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_f32::<BE>()?)
     }
 }
 
 impl McBufReadable for f64 {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_f64::<BE>()?)
     }
 }
 
 impl<T: McBufReadable> McBufReadable for Option<T> {
-    default fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let present = bool::read_from(buf)?;
         Ok(if present {
             Some(T::read_from(buf)?)
@@ -288,7 +305,7 @@ impl<T: McBufReadable> McBufReadable for Option<T> {
 }
 
 impl<T: McBufVarReadable> McBufVarReadable for Option<T> {
-    default fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let present = bool::read_from(buf)?;
         Ok(if present {
             Some(T::var_read_from(buf)?)
@@ -300,13 +317,13 @@ impl<T: McBufVarReadable> McBufVarReadable for Option<T> {
 
 // [String; 4]
 impl<T: McBufReadable, const N: usize> McBufReadable for [T; N] {
-    default fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    default fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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")
         })
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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);
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let string = String::read_from(buf)?;
         let json: serde_json::Value = serde_json::from_str(string.as_str())?;
         let component = Component::deserialize(json)?;

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) => {

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(Difficulty::by_id(u8::read_from(buf)?))
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let id = u8::read_from(buf)?;
         GameType::from_id(id).ok_or(BufReadError::UnexpectedEnumVariant { id: id as i32 })
     }
@@ -108,7 +108,7 @@ impl From<OptionalGameType> for Option<GameType> {
 }
 
 impl McBufReadable for OptionalGameType {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let id = i8::read_from(buf)?;
         GameType::from_optional_id(id).ok_or(BufReadError::UnexpectedEnumVariant { id: id as i32 })
     }

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<Self, BufReadError> {
+    pub fn read_from_particle_id(buf: &mut Cursor<&[u8]>, id: u32) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let id = u32::var_read_from(buf)?;
         ParticleData::read_from_particle_id(buf, id)
     }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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 buf = &mut &buf[..];
-        let block_pos = BlockPos::read_from(&mut buf).unwrap();
+        let block_pos = BlockPos::read_from(buf).unwrap();
         assert_eq!(block_pos, BlockPos::new(49, -43, -3));
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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(),

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let present = bool::read_from(buf)?;
         if !present {
             return Ok(Slot::Empty);

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();
+            black_box(Tag::read(&mut decoded_src_stream).unwrap());
-            owned_decoded_src_stream.seek(SeekFrom::Start(0)).unwrap();
+            decoded_src_stream.set_position(0);
-            Tag::read(&mut owned_decoded_src_stream).unwrap();
         })
     });
 

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<String, Error> {
+fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8], Error> {
-    let length = stream.read_u16::<BE>()?;
+    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];
+#[inline]
-    stream.read_exact(&mut buf)?;
+fn read_string(stream: &mut Cursor<&[u8]>) -> Result<String, Error> {
-    Ok(String::from_utf8(buf)?)
+    let length = stream.read_u16::<BE>()? 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<Tag, Error> {
+    fn read_known(stream: &mut Cursor<&[u8]>, id: u8) -> Result<Tag, Error> {
         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::<BE>()?;
+                let length = stream.read_u32::<BE>()? as usize;
-                let mut bytes = vec![0; length as usize];
+                let bytes = read_bytes(stream, length)?.to_vec();
-                stream.read_exact(&mut bytes)?;
                 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::<BE>()?;
+                let length = stream.read_u32::<BE>()?;
-                let mut list = Vec::with_capacity(length as usize);
+                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::<BE>()?;
+                let length = stream.read_u32::<BE>()? 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::<BE>()?);
@@ -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::<BE>()?;
+                let length = stream.read_u32::<BE>()? 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::<BE>()?);
@@ -105,7 +121,7 @@ impl Tag {
         })
     }
 
-    pub fn read(stream: &mut impl Read) -> Result<Tag, Error> {
+    pub fn read(stream: &mut Cursor<&[u8]>) -> Result<Tag, Error> {
         // 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<Tag, Error> {
         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<Tag, Error> {
+    pub fn read_gzip(stream: &mut Cursor<Vec<u8>>) -> Result<Tag, Error> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(Tag::read(buf)?)
     }
 }

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<std::io::Error> for Error {
         Error::WriteError(e)
     }
 }
-impl From<std::string::FromUtf8Error> for Error {
+impl From<std::str::Utf8Error> for Error {
-    fn from(e: std::string::FromUtf8Error) -> Self {
+    fn from(e: std::str::Utf8Error) -> Self {
         Error::Utf8Error(e)
     }
 }

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!(

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);
 }

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,

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<R: ProtocolPacket> {
     pub read_stream: OwnedReadHalf,
+    buffer: BytesMut,
     pub compression_threshold: Option<u32>,
     pub dec_cipher: Option<Aes128CfbDec>,
     _reading: PhantomData<R>,
@@ -41,6 +43,7 @@ where
     pub async fn read(&mut self) -> Result<R, ReadPacketError> {
         read_packet::<R, _>(
             &mut self.read_stream,
+            &mut self.buffer,
             self.compression_threshold,
             &mut self.dec_cipher,
         )
@@ -104,6 +107,7 @@ impl Connection<ClientboundHandshakePacket, ServerboundHandshakePacket> {
         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,

azalea-protocol/src/lib.rs

@@ -52,6 +52,8 @@ pub async fn connect(address: ServerAddress) -> Result<(), Box<dyn std::error::E
 
 #[cfg(test)]
 mod tests {
+    use std::io::Cursor;
+
     use crate::{
         packets::login::{
             serverbound_hello_packet::{ProfilePublicKeyData, ServerboundHelloPacket},
@@ -60,7 +62,7 @@ mod tests {
         read::read_packet,
         write::write_packet,
     };
-    use std::io::Cursor;
+    use bytes::BytesMut;
     use uuid::Uuid;
 
     #[tokio::test]
@@ -75,15 +77,22 @@ mod tests {
             profile_id: Some(Uuid::from_u128(0)),
         }
         .get();
-        let mut stream = Cursor::new(Vec::new());
+        let mut stream = Vec::new();
         write_packet(packet, &mut stream, None, &mut None)
             .await
             .unwrap();
 
-        stream.set_position(0);
+        println!("stream: {stream:?}");
 
-        let _ = read_packet::<ServerboundLoginPacket, _>(&mut stream, None, &mut None)
+        let mut stream = Cursor::new(stream);
-            .await
+
-            .unwrap();
+        let _ = read_packet::<ServerboundLoginPacket, _>(
+            &mut stream,
+            &mut BytesMut::new(),
+            None,
+            &mut None,
+        )
+        .await
+        .unwrap();
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         Ok(Self {
             darken_screen: byte & 1 != 0,

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<Self, BufReadError> {
+    fn read_from(_buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         // 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;

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<T> {
     max: Option<T>,
 }
 impl<T: McBufReadable> McBufReadable for BrigadierNumber<T> {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let flags = u8::read_from(buf)?;
         if flags > 31 {
             warn!(

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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);
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let particle_id = u32::var_read_from(buf)?;
         let override_limiter = bool::read_from(buf)?;
         let x = f64::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let map_id = u32::var_read_from(buf)?;
         let scale = u8::read_from(buf)?;
         let locked = bool::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         Ok(PlayerAbilitiesFlags {
             invulnerable: byte & 1 != 0,

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
         );
     }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let id = u8::read_from(buf)?;
         Ok(match id {
             0 => Action::AddPlayer(Vec::<AddPlayer>::read_from(buf)?),

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         Ok(RelativeArguments {
             x: byte & 0b1 != 0,

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<Self, azalea_buf::BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
         let action_id = u32::var_read_from(buf)?;
         let settings = RecipeBookSettings::read_from(buf)?;
         let recipes = Vec::<ResourceLocation>::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let data = u64::var_read_from(buf)?;
         let position_part = data & 4095;
         let state = (data >> 12) as u32;

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 std::io::Cursor;
-use azalea_buf::{McBufReadable, McBufWritable};
 
 #[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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let mut slots = vec![];
 
         loop {

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(match u8::read_from(buf)? {
             0 => Method::Add(DisplayInfo::read_from(buf)?),
             1 => Method::Remove,

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(match u8::read_from(buf)? {
             0 => Method::Add((Parameters::read_from(buf)?, PlayerList::read_from(buf)?)),
             1 => Method::Remove,

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let owner = String::read_from(buf)?;
         let method_id = u32::var_read_from(buf)?;
         let objective_name = String::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         let source = if byte & 1 != 0 {
             Some(SoundSource::read_from(buf)?)

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<Self, azalea_buf::BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
         let title = azalea_buf::McBufReadable::read_from(buf)?;
         let description = azalea_buf::McBufReadable::read_from(buf)?;
         let icon = azalea_buf::McBufReadable::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         match u8::read_from(buf)? {
             0 => Ok(Operation::Addition),
             1 => Ok(Operation::MultiplyBase),

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let recipe_type = ResourceLocation::read_from(buf)?;
         let identifier = ResourceLocation::read_from(buf)?;
 

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::{
+use std::{collections::HashMap, io::Write};
-    collections::HashMap,
-    io::{Read, Write},
-};
 
 #[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateTagsPacket {
@@ -23,7 +21,7 @@ pub struct Tags {
 pub struct TagMap(HashMap<ResourceLocation, Vec<Tags>>);
 
 impl McBufReadable for TagMap {
-    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let name = ResourceLocation::read_from(buf)?;
         let elements = Vec::<i32>::var_read_from(buf)?;
         Ok(Tags { name, elements })

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let action_type = u32::var_read_from(buf)?;
         match action_type {
             0 => {

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         Ok(Self {
             is_flying: byte & 2 != 0,

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let xxa = f32::read_from(buf)?;
         let zza = f32::read_from(buf)?;
         let byte = u8::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let action = Action::read_from(buf)?;
         let tab = if action == Action::OpenedTab {
             Some(ResourceLocation::read_from(buf)?)

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let pos = BlockPos::read_from(buf)?;
         let command = String::read_from(buf)?;
         let mode = Mode::read_from(buf)?;

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let name = String::read_from(buf)?;
         match name.as_str() {
             "rollable" => Ok(JointType::Rollable),

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let byte = u8::read_from(buf)?;
         Ok(Self {
             ignore_entities: byte & 1 != 0,

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let block_pos = BlockPos::read_from(buf)?;
         let direction = Direction::read_from(buf)?;
         let cursor_x = f32::read_from(buf)?;

azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs

@@ -1,31 +1,9 @@
-use super::ClientboundLoginPacket;
+use azalea_buf::McBuf;
-use azalea_buf::{BufReadError, McBufVarReadable, McBufVarWritable};
+use azalea_protocol_macros::ClientboundLoginPacket;
-use std::{
+use std::hash::Hash;
-    hash::Hash,
-    io::{Read, Write},
-};
 
-#[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<ClientboundLoginPacket, BufReadError> {
-        let compression_threshold = i32::var_read_from(buf)?;
-
-        Ok(ClientboundLoginCompressionPacket {
-            compression_threshold,
-        }
-        .get())
-    }
-}

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<u8> = 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);
     }
 }

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let is_nonce = bool::read_from(buf)?;
         if is_nonce {
             Ok(NonceOrSaltSignature::Nonce(Vec::<u8>::read_from(buf)?))

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<Self, ReadPacketError>;
+    fn read(id: u32, buf: &mut Cursor<&[u8]>) -> Result<Self, ReadPacketError>;
 
     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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let id = i32::var_read_from(buf)?;
         ConnectionProtocol::from_i32(id).ok_or(BufReadError::UnexpectedEnumVariant { id })
     }

azalea-protocol/src/packets/status/clientbound_status_response_packet.rs

@@ -1,14 +1,14 @@
-use super::ClientboundStatusPacket;
+use azalea_buf::{BufReadError, McBufReadable, McBufWritable};
-use azalea_buf::{BufReadError, McBufReadable};
 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<String>,
@@ -34,21 +34,17 @@ pub struct ClientboundStatusResponsePacket {
     pub version: Version,
 }
 
-impl ClientboundStatusResponsePacket {
+impl McBufReadable for ClientboundStatusResponsePacket {
-    pub fn get(self) -> ClientboundStatusPacket {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<ClientboundStatusResponsePacket, BufReadError> {
-        ClientboundStatusPacket::StatusResponse(self)
-    }
-
-    pub fn write(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
-        Ok(())
-    }
-
-    pub fn read(buf: &mut impl Read) -> Result<ClientboundStatusPacket, BufReadError> {
         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(ClientboundStatusResponsePacket::deserialize(status_json)?)
-
+    }
-        Ok(packet)
+}
+
+impl McBufWritable for ClientboundStatusResponsePacket {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
+        todo!()
     }
 }

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<R: ?Sized>(mut stream: &mut R) -> Result<Vec<u8>, FrameSplitterError>
+/// Read a length, then read that amount of bytes from BytesMut. If there's not
-where
+/// enough data, return None
-    R: AsyncRead + std::marker::Unpin + std::marker::Send,
+fn parse_frame(buffer: &mut BytesMut) -> Result<BytesMut, FrameSplitterError> {
-{
+    // 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
+    if length > buffer_copy.get_ref().len() {
-    // 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
         return Err(FrameSplitterError::BadLength {
-            max: max_length,
+            max: buffer_copy.get_ref().len(),
             size: length,
         });
     }
 
-    let mut buf = vec![0; length as usize];
+    // we read from the copy and we know it's legit, so we can take those bytes
-    stream.read_exact(&mut buf).await?;
+    // 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<P: ProtocolPacket>(stream: &mut impl Read) -> Result<P, ReadPacketError> {
+async fn frame_splitter<'a, R: ?Sized + Sized>(
+    stream: &mut R,
+    buffer: &'a mut BytesMut,
+) -> Result<Vec<u8>, 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<P: ProtocolPacket>(stream: &mut Cursor<&[u8]>) -> Result<P, ReadPacketError> {
     // 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<Vec<u8>, 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<u32>,
     cipher: &mut Option<Aes128CfbDec>,
 ) -> Result<P, ReadPacketError>
@@ -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,

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, BufReadError> {
         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<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let block_count = u16::read_from(buf)?;
 
         // this is commented out because the vanilla server is wrong

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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         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<Self, BufReadError> {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let data_type = u32::var_read_from(buf)?;
         Ok(match data_type {
             0 => EntityDataValue::Byte(u8::read_from(buf)?),

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)
     }

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<Self, BufReadError> {
         let bits_per_entry = u8::read_from(buf)?;
@@ -256,7 +256,7 @@ impl PaletteType {
         }
     }
 
-    pub fn read(&self, buf: &mut impl Read) -> Result<Palette, BufReadError> {
+    pub fn read(&self, buf: &mut Cursor<&[u8]>) -> Result<Palette, BufReadError> {
         Ok(match self {
             PaletteType::SingleValue => Palette::SingleValue(u32::var_read_from(buf)?),
             PaletteType::Linear => Palette::Linear(Vec::<u32>::var_read_from(buf)?),