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

start improving packet macros

Browse source
This commit is contained in:
mat 2022-01-02 17:03:34 -06:00
parent 3ec7352da2
commit bb57273f48
5 changed files with 592 additions and 519 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
azalea-protocol/packet-macros/src/lib.rs
View file

@ -32,13 +32,6 @@ fn as_packet_derive(
// i don't know how to do this in a way that isn't terrible
} else if path.to_token_stream().to_string() == "Vec < u8 >" {
quote! { buf.write_bytes(&self.#field_name)?; }
} else if path.is_ident("i32") {
// only treat it as a varint if it has the varint attribute
if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
quote! { buf.write_varint(self.#field_name)?; }
} else {
quote! { buf.write_i32(self.#field_name)?; }
}
} else if path.is_ident("u32") {
if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
quote! { buf.write_varint(self.#field_name as i32)?; }
@ -50,10 +43,16 @@ fn as_packet_derive(
} else if path.is_ident("ConnectionProtocol") {
quote! { buf.write_varint(self.#field_name.clone() as i32)?; }
} else {
panic!(
"#[derive(*Packet)] doesn't know how to write {}",
path.to_token_stream()
);
if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
quote! {
crate::mc_buf::McBufVarintWritable::varint_write_into(&self.#field_name, buf)?;
}
} else {
quote! {
crate::mc_buf::McBufVarintWritable::write_into(&self.#field_name, buf)?;
}
}
}
}
_ => panic!(
@ -78,16 +77,8 @@ fn as_packet_derive(
quote! { let #field_name = buf.read_utf().await?; }
} else if path.is_ident("ResourceLocation") {
quote! { let #field_name = buf.read_resource_location().await?; }
// i don't know how to do this in a way that isn't terrible
} else if path.to_token_stream().to_string() == "Vec < u8 >" {
quote! { let #field_name = buf.read_bytes().await?; }
} else if path.is_ident("i32") {
// only treat it as a varint if it has the varint attribute
if f.attrs.iter().any(|a| a.path.is_ident("varint")) {
quote! { let #field_name = buf.read_varint().await?; }
} else {
quote! { let #field_name = buf.read_i32().await?; }
}
} else if path.is_ident("u32") {
if f.attrs.iter().any(|a| a.path.is_ident("varint")) {
quote! { let #field_name = buf.read_varint().await? as u32; }
@ -102,10 +93,15 @@ fn as_packet_derive(
.ok_or_else(|| "Invalid intention".to_string())?;
}
} else {
panic!(
"#[derive(*Packet)] doesn't know how to read {}",
path.to_token_stream()
);
if f.attrs.iter().any(|a| a.path.is_ident("varint")) {
quote! {
let #field_name = crate::mc_buf::McBufVarintReadable::varint_read_into(buf).await?;
}
} else {
quote! {
let #field_name = crate::mc_buf::McBufReadable::read_into(buf).await?;
}
}
}
}
_ => panic!(

496
azalea-protocol/src/mc_buf.rs
View file

@ -1,496 +0,0 @@
//! Utilities for reading and writing for the Minecraft protocol
use std::io::Write;
use async_trait::async_trait;
use azalea_core::resource_location::ResourceLocation;
use byteorder::{BigEndian, WriteBytesExt};
use tokio::io::{AsyncRead, AsyncReadExt};
// const DEFAULT_NBT_QUOTA: u32 = 2097152;
const MAX_STRING_LENGTH: u16 = 32767;
// const MAX_COMPONENT_STRING_LENGTH: u32 = 262144;
#[async_trait]
pub trait Writable {
fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
where
F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
T: Sized,
Self: Sized;
fn write_int_id_list(&mut self, list: Vec<i32>) -> Result<(), std::io::Error>;
fn write_map<KF, VF, KT, VT>(
&mut self,
map: Vec<(KT, VT)>,
key_writer: KF,
value_writer: VF,
) -> Result<(), std::io::Error>
where
KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
Self: Sized;
fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error>;
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
fn write_varint(&mut self, value: i32) -> Result<(), std::io::Error>;
fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error>;
fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error>;
fn write_short(&mut self, n: i16) -> Result<(), std::io::Error>;
fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
fn write_int(&mut self, n: i32) -> Result<(), std::io::Error>;
fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error>;
fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>;
fn write_long(&mut self, n: i64) -> Result<(), std::io::Error>;
fn write_resource_location(
&mut self,
location: &ResourceLocation,
) -> Result<(), std::io::Error>;
}
#[async_trait]
impl Writable for Vec<u8> {
fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
where
F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
Self: Sized,
{
self.write_varint(list.len() as i32)?;
for item in list {
writer(self, item)?;
}
Ok(())
}
fn write_int_id_list(&mut self, list: Vec<i32>) -> Result<(), std::io::Error> {
self.write_list(&list, |buf, n| buf.write_varint(*n))
}
fn write_map<KF, VF, KT, VT>(
&mut self,
map: Vec<(KT, VT)>,
key_writer: KF,
value_writer: VF,
) -> Result<(), std::io::Error>
where
KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
Self: Sized,
{
self.write_varint(map.len() as i32)?;
for (key, value) in map {
key_writer(self, key)?;
value_writer(self, value)?;
}
Ok(())
}
fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error> {
WriteBytesExt::write_u8(self, n)
}
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
self.extend_from_slice(bytes);
Ok(())
}
fn write_varint(&mut self, mut value: i32) -> Result<(), std::io::Error> {
let mut buffer = [0];
if value == 0 {
self.write_all(&buffer).unwrap();
}
while value != 0 {
buffer[0] = (value & 0b0111_1111) as u8;
value = (value >> 7) & (i32::max_value() >> 6);
if value != 0 {
buffer[0] |= 0b1000_0000;
}
self.write_all(&buffer)?;
}
Ok(())
}
fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error> {
if string.len() > len {
panic!(
"String too big (was {} bytes encoded, max {})",
string.len(),
len
);
}
self.write_varint(string.len() as i32)?;
self.write_bytes(string.as_bytes())
}
fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error> {
self.write_utf_with_len(string, MAX_STRING_LENGTH.into())
}
fn write_short(&mut self, n: i16) -> Result<(), std::io::Error> {
WriteBytesExt::write_i16::<BigEndian>(self, n)
}
fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
self.write_varint(bytes.len() as i32)?;
self.write_bytes(bytes)
}
fn write_int(&mut self, n: i32) -> Result<(), std::io::Error> {
WriteBytesExt::write_i32::<BigEndian>(self, n)
}
fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error> {
self.write_byte(if b { 1 } else { 0 })
}
fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error> {
nbt.write(self)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
}
fn write_long(&mut self, n: i64) -> Result<(), std::io::Error> {
WriteBytesExt::write_i64::<BigEndian>(self, n)
}
fn write_resource_location(
&mut self,
location: &ResourceLocation,
) -> Result<(), std::io::Error> {
self.write_utf(&location.to_string())
}
}
#[async_trait]
pub trait Readable {
async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String>;
async fn read_varint(&mut self) -> Result<i32, String>;
fn get_varint_size(&mut self, value: i32) -> u8;
fn get_varlong_size(&mut self, value: i32) -> u8;
async fn read_byte_array(&mut self) -> Result<Vec<u8>, String>;
async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String>;
async fn read_bytes(&mut self) -> Result<Vec<u8>, String>;
async fn read_utf(&mut self) -> Result<String, String>;
async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String>;
async fn read_byte(&mut self) -> Result<u8, String>;
async fn read_int(&mut self) -> Result<i32, String>;
async fn read_boolean(&mut self) -> Result<bool, String>;
async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String>;
async fn read_long(&mut self) -> Result<i64, String>;
async fn read_resource_location(&mut self) -> Result<ResourceLocation, String>;
async fn read_short(&mut self) -> Result<i16, String>;
}
#[async_trait]
impl<R> Readable for R
where
R: AsyncRead + std::marker::Unpin + std::marker::Send,
{
async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String> {
let len = self.read_varint().await?;
let mut list = Vec::with_capacity(len as usize);
for _ in 0..len {
list.push(self.read_varint().await?);
}
Ok(list)
}
// fast varints stolen 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
async fn read_varint(&mut self) -> Result<i32, String> {
let mut buffer = [0];
let mut ans = 0;
for i in 0..4 {
self.read_exact(&mut buffer)
.await
.map_err(|_| "Invalid VarInt".to_string())?;
ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
if buffer[0] & 0b1000_0000 == 0 {
return Ok(ans);
}
}
Ok(ans)
}
fn get_varint_size(&mut self, value: i32) -> u8 {
for i in 1..5 {
if (value & -1 << (i * 7)) != 0 {
continue;
}
return i;
}
5
}
fn get_varlong_size(&mut self, value: i32) -> u8 {
for i in 1..10 {
if (value & -1 << (i * 7)) != 0 {
continue;
}
return i;
}
10
}
async fn read_byte_array(&mut self) -> Result<Vec<u8>, String> {
let length = self.read_varint().await? as usize;
Ok(self.read_bytes_with_len(length).await?)
}
async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String> {
let mut bytes = vec![0; n];
match AsyncReadExt::read_exact(self, &mut bytes).await {
Ok(_) => Ok(bytes),
Err(_) => Err("Error reading bytes".to_string()),
}
}
async fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
// read to end of the buffer
let mut bytes = vec![];
AsyncReadExt::read_to_end(self, &mut bytes)
.await
.map_err(|_| "Error reading bytes".to_string())?;
Ok(bytes)
}
async fn read_utf(&mut self) -> Result<String, String> {
self.read_utf_with_len(MAX_STRING_LENGTH.into()).await
}
async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String> {
let length = self.read_varint().await?;
// i don't know why it's multiplied by 4 but it's like that in mojang's code so
if length < 0 {
return Err(
"The received encoded string buffer length is less than zero! Weird string!"
.to_string(),
);
}
if length as u32 > max_length * 4 {
return Err(format!(
"The received encoded string buffer length is longer than maximum allowed ({} > {})",
length,
max_length * 4
));
}
// this is probably quite inefficient, idk how to do it better
let mut string = String::new();
let mut buffer = vec![0; length as usize];
self.read_exact(&mut buffer)
.await
.map_err(|_| "Invalid UTF-8".to_string())?;
string.push_str(std::str::from_utf8(&buffer).unwrap());
if string.len() > length as usize {
return Err(format!(
"The received string length is longer than maximum allowed ({} > {})",
length, max_length
));
}
Ok(string)
}
/// Read a single byte from the reader
async fn read_byte(&mut self) -> Result<u8, String> {
match AsyncReadExt::read_u8(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading byte".to_string()),
}
}
async fn read_int(&mut self) -> Result<i32, String> {
match AsyncReadExt::read_i32(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading int".to_string()),
}
}
async fn read_boolean(&mut self) -> Result<bool, String> {
match self.read_byte().await {
Ok(0) => Ok(false),
Ok(1) => Ok(true),
_ => Err("Error reading boolean".to_string()),
}
}
async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String> {
match azalea_nbt::Tag::read(self).await {
Ok(r) => Ok(r),
// Err(e) => Err(e.to_string()),
Err(e) => Err(e.to_string()).unwrap(),
}
}
async fn read_long(&mut self) -> Result<i64, String> {
match AsyncReadExt::read_i64(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading long".to_string()),
}
}
async fn read_resource_location(&mut self) -> Result<ResourceLocation, String> {
// get the resource location from the string
let location_string = self.read_utf().await?;
let location = ResourceLocation::new(&location_string)?;
Ok(location)
}
async fn read_short(&mut self) -> Result<i16, String> {
match AsyncReadExt::read_i16(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading short".to_string()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::{collections::HashMap, io::Cursor};
use tokio::io::BufReader;
#[test]
fn test_write_varint() {
let mut buf = Vec::new();
buf.write_varint(123456).unwrap();
assert_eq!(buf, vec![192, 196, 7]);
let mut buf = Vec::new();
buf.write_varint(0).unwrap();
assert_eq!(buf, vec![0]);
}
#[tokio::test]
async fn test_read_varint() {
let mut buf = BufReader::new(Cursor::new(vec![192, 196, 7]));
assert_eq!(buf.read_varint().await.unwrap(), 123456);
assert_eq!(buf.get_varint_size(123456), 3);
let mut buf = BufReader::new(Cursor::new(vec![0]));
assert_eq!(buf.read_varint().await.unwrap(), 0);
assert_eq!(buf.get_varint_size(0), 1);
let mut buf = BufReader::new(Cursor::new(vec![1]));
assert_eq!(buf.read_varint().await.unwrap(), 1);
assert_eq!(buf.get_varint_size(1), 1);
}
#[tokio::test]
async fn test_read_varint_longer() {
let mut buf = BufReader::new(Cursor::new(vec![138, 56, 0, 135, 56, 123]));
assert_eq!(buf.read_varint().await.unwrap(), 7178);
}
#[tokio::test]
async fn test_list() {
let mut buf = Vec::new();
buf.write_list(&vec!["a", "bc", "def"], |buf, s| buf.write_utf(s))
.unwrap();
// there's no read_list because idk how to do it in rust
let mut buf = BufReader::new(Cursor::new(buf));
let mut result = Vec::new();
let length = buf.read_varint().await.unwrap();
for _ in 0..length {
result.push(buf.read_utf().await.unwrap());
}
assert_eq!(result, vec!["a", "bc", "def"]);
}
#[tokio::test]
async fn test_int_id_list() {
let mut buf = Vec::new();
buf.write_list(&vec![1, 2, 3], |buf, i| buf.write_varint(*i))
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let result = buf.read_int_id_list().await.unwrap();
assert_eq!(result, vec![1, 2, 3]);
}
#[tokio::test]
async fn test_map() {
let mut buf = Vec::new();
buf.write_map(
vec![("a", 1), ("bc", 23), ("def", 456)],
Vec::write_utf,
Vec::write_varint,
)
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let mut result = Vec::new();
let length = buf.read_varint().await.unwrap();
for _ in 0..length {
result.push((
buf.read_utf().await.unwrap(),
buf.read_varint().await.unwrap(),
));
}
assert_eq!(
result,
vec![
("a".to_string(), 1),
("bc".to_string(), 23),
("def".to_string(), 456)
]
);
}
#[tokio::test]
async fn test_nbt() {
let mut buf = Vec::new();
buf.write_nbt(&azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"hello world".to_string(),
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"name".to_string(),
azalea_nbt::Tag::String("Bananrama".to_string()),
)])),
)])))
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let result = buf.read_nbt().await.unwrap();
assert_eq!(
result,
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"hello world".to_string(),
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"name".to_string(),
azalea_nbt::Tag::String("Bananrama".to_string()),
)])),
)]))
);
}
#[tokio::test]
async fn test_long() {
let mut buf = Vec::new();
buf.write_long(123456).unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
assert_eq!(buf.read_long().await.unwrap(), 123456);
}
#[tokio::test]
async fn test_resource_location() {
let mut buf = Vec::new();
buf.write_resource_location(&ResourceLocation::new("minecraft:dirt").unwrap())
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
assert_eq!(
buf.read_resource_location().await.unwrap(),
ResourceLocation::new("minecraft:dirt").unwrap()
);
}
}

163
azalea-protocol/src/mc_buf/mod.rs Normal file
View file

@ -0,0 +1,163 @@
//! Utilities for reading and writing for the Minecraft protocol
mod read;
mod write;
pub use read::{McBufReadable, McBufVarintReadable, Readable};
pub use write::{McBufVarintWritable, McBufWritable, Writable};
// const DEFAULT_NBT_QUOTA: u32 = 2097152;
const MAX_STRING_LENGTH: u16 = 32767;
// const MAX_COMPONENT_STRING_LENGTH: u32 = 262144;
#[cfg(test)]
mod tests {
use super::*;
use azalea_core::resource_location::ResourceLocation;
use std::{collections::HashMap, io::Cursor};
use tokio::io::BufReader;
#[test]
fn test_write_varint() {
let mut buf = Vec::new();
buf.write_varint(123456).unwrap();
assert_eq!(buf, vec![192, 196, 7]);
let mut buf = Vec::new();
buf.write_varint(0).unwrap();
assert_eq!(buf, vec![0]);
}
#[tokio::test]
async fn test_read_varint() {
let mut buf = BufReader::new(Cursor::new(vec![192, 196, 7]));
assert_eq!(buf.read_varint().await.unwrap(), 123456);
assert_eq!(buf.get_varint_size(123456), 3);
let mut buf = BufReader::new(Cursor::new(vec![0]));
assert_eq!(buf.read_varint().await.unwrap(), 0);
assert_eq!(buf.get_varint_size(0), 1);
let mut buf = BufReader::new(Cursor::new(vec![1]));
assert_eq!(buf.read_varint().await.unwrap(), 1);
assert_eq!(buf.get_varint_size(1), 1);
}
#[tokio::test]
async fn test_read_varint_longer() {
let mut buf = BufReader::new(Cursor::new(vec![138, 56, 0, 135, 56, 123]));
assert_eq!(buf.read_varint().await.unwrap(), 7178);
}
#[tokio::test]
async fn test_list() {
let mut buf = Vec::new();
buf.write_list(&vec!["a", "bc", "def"], |buf, s| buf.write_utf(s))
.unwrap();
// there's no read_list because idk how to do it in rust
let mut buf = BufReader::new(Cursor::new(buf));
let mut result = Vec::new();
let length = buf.read_varint().await.unwrap();
for _ in 0..length {
result.push(buf.read_utf().await.unwrap());
}
assert_eq!(result, vec!["a", "bc", "def"]);
}
#[tokio::test]
async fn test_int_id_list() {
let mut buf = Vec::new();
buf.write_list(&vec![1, 2, 3], |buf, i| buf.write_varint(*i))
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let result = buf.read_int_id_list().await.unwrap();
assert_eq!(result, vec![1, 2, 3]);
}
#[tokio::test]
async fn test_map() {
let mut buf = Vec::new();
buf.write_map(
vec![("a", 1), ("bc", 23), ("def", 456)],
Vec::write_utf,
Vec::write_varint,
)
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let mut result = Vec::new();
let length = buf.read_varint().await.unwrap();
for _ in 0..length {
result.push((
buf.read_utf().await.unwrap(),
buf.read_varint().await.unwrap(),
));
}
assert_eq!(
result,
vec![
("a".to_string(), 1),
("bc".to_string(), 23),
("def".to_string(), 456)
]
);
}
#[tokio::test]
async fn test_nbt() {
let mut buf = Vec::new();
buf.write_nbt(&azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"hello world".to_string(),
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"name".to_string(),
azalea_nbt::Tag::String("Bananrama".to_string()),
)])),
)])))
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
let result = buf.read_nbt().await.unwrap();
assert_eq!(
result,
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"hello world".to_string(),
azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
"name".to_string(),
azalea_nbt::Tag::String("Bananrama".to_string()),
)])),
)]))
);
}
#[tokio::test]
async fn test_long() {
let mut buf = Vec::new();
buf.write_long(123456).unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
assert_eq!(buf.read_long().await.unwrap(), 123456);
}
#[tokio::test]
async fn test_resource_location() {
let mut buf = Vec::new();
buf.write_resource_location(&ResourceLocation::new("minecraft:dirt").unwrap())
.unwrap();
let mut buf = BufReader::new(Cursor::new(buf));
assert_eq!(
buf.read_resource_location().await.unwrap(),
ResourceLocation::new("minecraft:dirt").unwrap()
);
}
}

230
azalea-protocol/src/mc_buf/read.rs Normal file
View file

@ -0,0 +1,230 @@
use async_trait::async_trait;
use azalea_core::resource_location::ResourceLocation;
use tokio::io::{AsyncRead, AsyncReadExt};
use super::MAX_STRING_LENGTH;
#[async_trait]
pub trait Readable {
async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String>;
async fn read_varint(&mut self) -> Result<i32, String>;
fn get_varint_size(&mut self, value: i32) -> u8;
fn get_varlong_size(&mut self, value: i32) -> u8;
async fn read_byte_array(&mut self) -> Result<Vec<u8>, String>;
async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String>;
async fn read_bytes(&mut self) -> Result<Vec<u8>, String>;
async fn read_utf(&mut self) -> Result<String, String>;
async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String>;
async fn read_byte(&mut self) -> Result<u8, String>;
async fn read_int(&mut self) -> Result<i32, String>;
async fn read_boolean(&mut self) -> Result<bool, String>;
async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String>;
async fn read_long(&mut self) -> Result<i64, String>;
async fn read_resource_location(&mut self) -> Result<ResourceLocation, String>;
async fn read_short(&mut self) -> Result<i16, String>;
}
#[async_trait]
impl<R> Readable for R
where
R: AsyncRead + std::marker::Unpin + std::marker::Send,
{
async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String> {
let len = self.read_varint().await?;
let mut list = Vec::with_capacity(len as usize);
for _ in 0..len {
list.push(self.read_varint().await?);
}
Ok(list)
}
// fast varints stolen 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
async fn read_varint(&mut self) -> Result<i32, String> {
let mut buffer = [0];
let mut ans = 0;
for i in 0..4 {
self.read_exact(&mut buffer)
.await
.map_err(|_| "Invalid VarInt".to_string())?;
ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
if buffer[0] & 0b1000_0000 == 0 {
return Ok(ans);
}
}
Ok(ans)
}
fn get_varint_size(&mut self, value: i32) -> u8 {
for i in 1..5 {
if (value & -1 << (i * 7)) != 0 {
continue;
}
return i;
}
5
}
fn get_varlong_size(&mut self, value: i32) -> u8 {
for i in 1..10 {
if (value & -1 << (i * 7)) != 0 {
continue;
}
return i;
}
10
}
async fn read_byte_array(&mut self) -> Result<Vec<u8>, String> {
let length = self.read_varint().await? as usize;
Ok(self.read_bytes_with_len(length).await?)
}
async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String> {
let mut bytes = vec![0; n];
match AsyncReadExt::read_exact(self, &mut bytes).await {
Ok(_) => Ok(bytes),
Err(_) => Err("Error reading bytes".to_string()),
}
}
async fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
// read to end of the buffer
let mut bytes = vec![];
AsyncReadExt::read_to_end(self, &mut bytes)
.await
.map_err(|_| "Error reading bytes".to_string())?;
Ok(bytes)
}
async fn read_utf(&mut self) -> Result<String, String> {
self.read_utf_with_len(MAX_STRING_LENGTH.into()).await
}
async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String> {
let length = self.read_varint().await?;
// i don't know why it's multiplied by 4 but it's like that in mojang's code so
if length < 0 {
return Err(
"The received encoded string buffer length is less than zero! Weird string!"
.to_string(),
);
}
if length as u32 > max_length * 4 {
return Err(format!(
"The received encoded string buffer length is longer than maximum allowed ({} > {})",
length,
max_length * 4
));
}
// this is probably quite inefficient, idk how to do it better
let mut string = String::new();
let mut buffer = vec![0; length as usize];
self.read_exact(&mut buffer)
.await
.map_err(|_| "Invalid UTF-8".to_string())?;
string.push_str(std::str::from_utf8(&buffer).unwrap());
if string.len() > length as usize {
return Err(format!(
"The received string length is longer than maximum allowed ({} > {})",
length, max_length
));
}
Ok(string)
}
/// Read a single byte from the reader
async fn read_byte(&mut self) -> Result<u8, String> {
match AsyncReadExt::read_u8(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading byte".to_string()),
}
}
async fn read_int(&mut self) -> Result<i32, String> {
match AsyncReadExt::read_i32(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading int".to_string()),
}
}
async fn read_boolean(&mut self) -> Result<bool, String> {
match self.read_byte().await {
Ok(0) => Ok(false),
Ok(1) => Ok(true),
_ => Err("Error reading boolean".to_string()),
}
}
async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String> {
match azalea_nbt::Tag::read(self).await {
Ok(r) => Ok(r),
// Err(e) => Err(e.to_string()),
Err(e) => Err(e.to_string()).unwrap(),
}
}
async fn read_long(&mut self) -> Result<i64, String> {
match AsyncReadExt::read_i64(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading long".to_string()),
}
}
async fn read_resource_location(&mut self) -> Result<ResourceLocation, String> {
// get the resource location from the string
let location_string = self.read_utf().await?;
let location = ResourceLocation::new(&location_string)?;
Ok(location)
}
async fn read_short(&mut self) -> Result<i16, String> {
match AsyncReadExt::read_i16(self).await {
Ok(r) => Ok(r),
Err(_) => Err("Error reading short".to_string()),
}
}
}
#[async_trait]
pub trait McBufReadable
where
Self: Sized,
{
async fn read_into<R>(buf: &mut R) -> Result<Self, String>
where
R: AsyncRead + std::marker::Unpin + std::marker::Send;
}
#[async_trait]
pub trait McBufVarintReadable
where
Self: Sized,
{
async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
where
R: AsyncRead + std::marker::Unpin + std::marker::Send;
}
#[async_trait]
impl McBufReadable for i32 {
async fn read_into<R>(buf: &mut R) -> Result<Self, String>
where
R: AsyncRead + std::marker::Unpin + std::marker::Send,
{
buf.read_int().await
}
}
#[async_trait]
impl McBufVarintReadable for i32 {
async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
where
R: AsyncRead + std::marker::Unpin + std::marker::Send,
{
buf.read_varint().await
}
}

180
azalea-protocol/src/mc_buf/write.rs Normal file
View file

@ -0,0 +1,180 @@
use async_trait::async_trait;
use azalea_core::resource_location::ResourceLocation;
use byteorder::{BigEndian, WriteBytesExt};
use std::io::Write;
use super::MAX_STRING_LENGTH;
#[async_trait]
pub trait Writable {
fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
where
F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
T: Sized,
Self: Sized;
fn write_int_id_list(&mut self, list: Vec<i32>) -> Result<(), std::io::Error>;
fn write_map<KF, VF, KT, VT>(
&mut self,
map: Vec<(KT, VT)>,
key_writer: KF,
value_writer: VF,
) -> Result<(), std::io::Error>
where
KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
Self: Sized;
fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error>;
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
fn write_varint(&mut self, value: i32) -> Result<(), std::io::Error>;
fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error>;
fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error>;
fn write_short(&mut self, n: i16) -> Result<(), std::io::Error>;
fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
fn write_int(&mut self, n: i32) -> Result<(), std::io::Error>;
fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error>;
fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>;
fn write_long(&mut self, n: i64) -> Result<(), std::io::Error>;
fn write_resource_location(
&mut self,
location: &ResourceLocation,
) -> Result<(), std::io::Error>;
}
#[async_trait]
impl Writable for Vec<u8> {
fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
where
F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
Self: Sized,
{
self.write_varint(list.len() as i32)?;
for item in list {
writer(self, item)?;
}
Ok(())
}
fn write_int_id_list(&mut self, list: Vec<i32>) -> Result<(), std::io::Error> {
self.write_list(&list, |buf, n| buf.write_varint(*n))
}
fn write_map<KF, VF, KT, VT>(
&mut self,
map: Vec<(KT, VT)>,
key_writer: KF,
value_writer: VF,
) -> Result<(), std::io::Error>
where
KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
Self: Sized,
{
self.write_varint(map.len() as i32)?;
for (key, value) in map {
key_writer(self, key)?;
value_writer(self, value)?;
}
Ok(())
}
fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error> {
WriteBytesExt::write_u8(self, n)
}
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
self.extend_from_slice(bytes);
Ok(())
}
fn write_varint(&mut self, mut value: i32) -> Result<(), std::io::Error> {
let mut buffer = [0];
if value == 0 {
self.write_all(&buffer).unwrap();
}
while value != 0 {
buffer[0] = (value & 0b0111_1111) as u8;
value = (value >> 7) & (i32::max_value() >> 6);
if value != 0 {
buffer[0] |= 0b1000_0000;
}
self.write_all(&buffer)?;
}
Ok(())
}
fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error> {
if string.len() > len {
panic!(
"String too big (was {} bytes encoded, max {})",
string.len(),
len
);
}
self.write_varint(string.len() as i32)?;
self.write_bytes(string.as_bytes())
}
fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error> {
self.write_utf_with_len(string, MAX_STRING_LENGTH.into())
}
fn write_short(&mut self, n: i16) -> Result<(), std::io::Error> {
WriteBytesExt::write_i16::<BigEndian>(self, n)
}
fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
self.write_varint(bytes.len() as i32)?;
self.write_bytes(bytes)
}
fn write_int(&mut self, n: i32) -> Result<(), std::io::Error> {
WriteBytesExt::write_i32::<BigEndian>(self, n)
}
fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error> {
self.write_byte(if b { 1 } else { 0 })
}
fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error> {
nbt.write(self)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
}
fn write_long(&mut self, n: i64) -> Result<(), std::io::Error> {
WriteBytesExt::write_i64::<BigEndian>(self, n)
}
fn write_resource_location(
&mut self,
location: &ResourceLocation,
) -> Result<(), std::io::Error> {
self.write_utf(&location.to_string())
}
}
pub trait McBufWritable
where
Self: Sized,
{
fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
}
pub trait McBufVarintWritable
where
Self: Sized,
{
fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
}
impl McBufWritable for i32 {
fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
Writable::write_int(buf, *self)
}
}
impl McBufVarintWritable for i32 {
fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
buf.write_varint(*self)
}
}