mat/azalea
1
2
Fork 0
mirror of https://github.com/mat-1/azalea.git synced 2025-08-02 06:16:04 +00:00
Code Issues Projects Releases Packages Activity

Merge branch 'main' into pathfinding

Browse source
This commit is contained in:
mat 2022-10-07 20:13:04 -05:00
commit e00d5c421e
61 changed files with 435 additions and 346 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
azalea-block/src/lib.rs
View file

@ -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,

4
azalea-buf/azalea-buf-macros/src/lib.rs
View file

@ -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 {

4
azalea-buf/src/definitions.rs
View file

@ -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

73
azalea-buf/src/lib.rs
View file

@ -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::<String>::read_from(&mut buf).unwrap();
let buf = &mut &buf[..];
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();
123456u64.write_into(&mut buf).unwrap();
let buf: &mut Vec<u8> = &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);
}
}

145
azalea-buf/src/read.rs
View file

@ -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 mut string = String::new();
let mut buffer = vec![0; length as usize];
buf.read_exact(&mut buffer)
.map_err(|_| BufReadError::InvalidUtf8)?;
string.push_str(std::str::from_utf8(&buffer).map_err(|_| BufReadError::InvalidUtf8)?);
let buffer = read_bytes(buf, length as usize)?;
let string = std::str::from_utf8(buffer)
.map_err(|_| BufReadError::InvalidUtf8)?
.to_string();
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(
reader: &mut (dyn AsyncRead + Unpin + Send),
) -> Result<i32, BufReadError> {
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<i32, BufReadError> {
// 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<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![];
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<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];
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<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")
})
}
}

6
azalea-buf/src/serializable_uuid.rs
View file

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

4
azalea-chat/src/component.rs
View file

@ -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)?;

8
azalea-client/src/client.rs
View file

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

4
azalea-core/src/difficulty.rs
View file

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

6
azalea-core/src/game_type.rs
View file

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

6
azalea-core/src/particle/mod.rs
View file

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

16
azalea-core/src/position.rs
View file

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

8
azalea-core/src/resource_location.rs
View file

@ -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(),

4
azalea-core/src/slot.rs
View file

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

16
azalea-nbt/benches/my_benchmark.rs
View file

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

56
azalea-nbt/src/decode.rs
View file

@ -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> {
let length = stream.read_u16::<BE>()?;
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<String, Error> {
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 mut bytes = vec![0; length as usize];
stream.read_exact(&mut bytes)?;
let length = stream.read_u32::<BE>()? 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::<BE>()?;
let mut list = Vec::with_capacity(length as usize);
let length = stream.read_u32::<BE>()?;
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)?)
}
}

8
azalea-nbt/src/error.rs
View file

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

5
azalea-nbt/src/lib.rs
View file

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

24
azalea-nbt/tests/tests.rs
View file

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

11
azalea-protocol/azalea-protocol-macros/src/lib.rs
View file

@ -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,

5
azalea-protocol/src/connect.rs Executable file → Normal file
View file

@ -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,

21
azalea-protocol/src/lib.rs
View file

@ -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)
.await
.unwrap();
let mut stream = Cursor::new(stream);
let _ = read_packet::<ServerboundLoginPacket, _>(
&mut stream,
&mut BytesMut::new(),
None,
&mut None,
)
.await
.unwrap();
}
}

8
azalea-protocol/src/packets/game/clientbound_boss_event_packet.rs
View file

@ -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,

4
azalea-protocol/src/packets/game/clientbound_command_suggestions_packet.rs
View file

@ -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;

9
azalea-protocol/src/packets/game/clientbound_commands_packet.rs
View file

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

6
azalea-protocol/src/packets/game/clientbound_explode_packet.rs
View file

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

4
azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs
View file

@ -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)?;

5
azalea-protocol/src/packets/game/clientbound_map_item_data_packet.rs
View file

@ -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)?;

4
azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
View file

@ -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,

4
azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs
View file

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

4
azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
View file

@ -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)?),

4
azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
View file

@ -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,

5
azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
View file

@ -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)?;

4
azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
View file

@ -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;

6
azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs
View file

@ -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<Self, BufReadError> {
fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
let mut slots = vec![];
loop {

4
azalea-protocol/src/packets/game/clientbound_set_objective_packet.rs
View file

@ -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,

5
azalea-protocol/src/packets/game/clientbound_set_player_team_packet.rs
View file

@ -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,

4
azalea-protocol/src/packets/game/clientbound_set_score_packet.rs
View file

@ -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)?;

5
azalea-protocol/src/packets/game/clientbound_stop_sound_packet.rs
View file

@ -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)?)

3
azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs
View file

@ -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)?;

4
azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
View file

@ -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),

6
azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
View file

@ -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)?;

10
azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
View file

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

4
azalea-protocol/src/packets/game/serverbound_interact_packet.rs
View file

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

3
azalea-protocol/src/packets/game/serverbound_player_abilities_packet.rs
View file

@ -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,

4
azalea-protocol/src/packets/game/serverbound_player_input_packet.rs
View file

@ -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)?;

3
azalea-protocol/src/packets/game/serverbound_seen_advancements_packet.rs
View file

@ -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)?)

3
azalea-protocol/src/packets/game/serverbound_set_command_block_packet.rs
View file

@ -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)?;

5
azalea-protocol/src/packets/game/serverbound_set_jigsaw_block_packet.rs
View file

@ -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),

4
azalea-protocol/src/packets/game/serverbound_set_structure_block_packet.rs
View file

@ -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,

4
azalea-protocol/src/packets/game/serverbound_use_item_on_packet.rs
View file

@ -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)?;

32
azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
View file

@ -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<ClientboundLoginPacket, BufReadError> {
let compression_threshold = i32::var_read_from(buf)?;
Ok(ClientboundLoginCompressionPacket {
compression_threshold,
}
.get())
}
}

6
azalea-protocol/src/packets/login/serverbound_hello_packet.rs
View file

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

4
azalea-protocol/src/packets/login/serverbound_key_packet.rs
View file

@ -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)?))

6
azalea-protocol/src/packets/mod.rs
View file

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

32
azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
View file

@ -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<String>,
@ -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<ClientboundStatusPacket, BufReadError> {
impl McBufReadable for ClientboundStatusResponsePacket {
fn read_from(buf: &mut Cursor<&[u8]>) -> Result<ClientboundStatusResponsePacket, 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(packet)
Ok(ClientboundStatusResponsePacket::deserialize(status_json)?)
}
}
impl McBufWritable for ClientboundStatusResponsePacket {
fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
todo!()
}
}

98
azalea-protocol/src/read.rs Executable file → Normal file
View file

@ -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>
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<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
// 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<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,

11
azalea-world/src/chunk_storage.rs
View file

@ -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

6
azalea-world/src/entity/data.rs
View file

@ -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)?),

4
azalea-world/src/lib.rs
View file

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

6
azalea-world/src/palette.rs
View file

@ -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)?),