1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
mod extra;
mod primitives;
use std::{
backtrace::Backtrace,
io::{self, Cursor, Write},
};
use thiserror::Error;
/// A trait that's implemented on types that are used by the Minecraft protocol.
pub trait AzBuf
where
Self: Sized,
{
fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
fn azalea_write(&self, buf: &mut impl Write) -> io::Result<()>;
}
/// Used for types that have an alternative variable-length encoding.
///
/// This mostly exists for varints.
pub trait AzBufVar
where
Self: Sized,
{
fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
fn azalea_write_var(&self, buf: &mut impl Write) -> io::Result<()>;
}
/// Used for types that have some configurable limit.
///
/// For example, the implementation of this on `String` limits the maximum
/// length of the string.
///
/// This exists partially as an anti-abuse mechanism in Minecraft, so there is
/// no limited write function.
pub trait AzBufLimited
where
Self: Sized,
{
fn azalea_read_limited(buf: &mut Cursor<&[u8]>, limit: u32) -> Result<Self, BufReadError>;
}
#[derive(Debug, Error)]
pub enum BufReadError {
#[error("Invalid VarInt")]
InvalidVarInt,
#[error("Invalid VarLong")]
InvalidVarLong,
#[error("Error reading bytes")]
CouldNotReadBytes,
#[error(
"The received encoded string buffer length is longer than maximum allowed ({length} > {max_length})"
)]
StringLengthTooLong { length: u32, max_length: u32 },
#[error("The received Vec length is longer than maximum allowed ({length} > {max_length})")]
VecLengthTooLong { length: u32, max_length: u32 },
#[error("{source}")]
Io {
#[from]
#[backtrace]
source: io::Error,
},
#[error("Invalid UTF-8: {bytes:?} (lossy: {lossy:?})")]
InvalidUtf8 {
bytes: Vec<u8>,
lossy: String,
// backtrace: Backtrace,
},
#[error("Unexpected enum variant {id}")]
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,
backtrace: Backtrace,
},
#[error("{0}")]
Custom(String),
#[cfg(feature = "serde_json")]
#[error("{source}")]
Deserialization {
#[from]
#[backtrace]
source: serde_json::Error,
},
#[error("{source}")]
Nbt {
#[from]
#[backtrace]
source: simdnbt::Error,
},
#[error("{source}")]
DeserializeNbt {
#[from]
#[backtrace]
source: simdnbt::DeserializeError,
},
}
pub(crate) fn read_bytes<'a>(
buf: &'a mut Cursor<&[u8]>,
length: usize,
) -> Result<&'a [u8], BufReadError> {
if length > (buf.get_ref().len() - buf.position() as usize) {
return Err(BufReadError::UnexpectedEof {
attempted_read: length,
actual_read: buf.get_ref().len() - buf.position() as usize,
backtrace: Backtrace::capture(),
});
}
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)
}
pub(crate) fn read_utf_with_len<'a>(
buf: &'a mut Cursor<&[u8]>,
max_length: u32,
) -> Result<&'a str, BufReadError> {
let length = u32::azalea_read_var(buf)?;
// i don't know why it's multiplied by 4 but it's like that in mojang's code so
if length > max_length * 4 {
return Err(BufReadError::StringLengthTooLong {
length,
max_length: max_length * 4,
});
}
let buffer = read_bytes(buf, length as usize)?;
let string = std::str::from_utf8(buffer).map_err(|_| BufReadError::InvalidUtf8 {
bytes: buffer.to_vec(),
lossy: String::from_utf8_lossy(buffer).to_string(),
// backtrace: Backtrace::capture(),
})?;
if string.len() > length as usize {
return Err(BufReadError::StringLengthTooLong { length, max_length });
}
Ok(string)
}
pub(crate) fn write_utf_with_len(
buf: &mut impl Write,
string: &str,
max_len: u32,
) -> io::Result<()> {
let actual_len = string.len();
if actual_len > max_len as usize {
panic!("String too big (was {actual_len} bytes encoded, max {max_len})");
}
string.as_bytes().to_vec().azalea_write(buf)?;
Ok(())
}
|
