remove bytebuffer
This commit is contained in:
parent
33b71aac63
commit
9a42e5fa59
16 changed files with 80 additions and 86 deletions
6
src/data/mod.rs
Executable file
6
src/data/mod.rs
Executable file
|
|
@ -0,0 +1,6 @@
|
|||
pub mod reader;
|
||||
pub mod varint;
|
||||
pub mod writer;
|
||||
|
||||
pub use reader::*;
|
||||
pub use writer::*;
|
||||
215
src/data/reader.rs
Executable file
215
src/data/reader.rs
Executable file
|
|
@ -0,0 +1,215 @@
|
|||
use crate::{
|
||||
data::varint::{read_varint, size_varint},
|
||||
zigzag::Zigzag,
|
||||
ProtocolError,
|
||||
};
|
||||
use std::io::Read;
|
||||
use uuid::Uuid;
|
||||
|
||||
/// Packet data reader trait
|
||||
pub trait DataReader {
|
||||
/// Read bytes
|
||||
fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError>;
|
||||
|
||||
/// Read byte
|
||||
fn read_byte(&mut self) -> Result<u8, ProtocolError> {
|
||||
Ok(self.read_bytes(1)?[0])
|
||||
}
|
||||
/// Read String
|
||||
fn read_string(&mut self) -> Result<String, ProtocolError> {
|
||||
let size = self.read_usize_varint()?;
|
||||
match String::from_utf8(self.read_bytes(size)?) {
|
||||
Ok(i) => Ok(i),
|
||||
Err(_) => Err(ProtocolError::StringParseError),
|
||||
}
|
||||
}
|
||||
/// Read Unsigned Short as u16
|
||||
fn read_unsigned_short(&mut self) -> Result<u16, ProtocolError> {
|
||||
match self.read_bytes(2)?.try_into() {
|
||||
Ok(i) => Ok(u16::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read Boolean
|
||||
fn read_boolean(&mut self) -> Result<bool, ProtocolError> {
|
||||
Ok(self.read_byte()? == 0x01)
|
||||
}
|
||||
/// Read Short as i16
|
||||
fn read_short(&mut self) -> Result<i16, ProtocolError> {
|
||||
match self.read_bytes(2)?.try_into() {
|
||||
Ok(i) => Ok(i16::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read Long as i64
|
||||
fn read_long(&mut self) -> Result<i64, ProtocolError> {
|
||||
match self.read_bytes(8)?.try_into() {
|
||||
Ok(i) => Ok(i64::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read Float as f32
|
||||
fn read_float(&mut self) -> Result<f32, ProtocolError> {
|
||||
match self.read_bytes(4)?.try_into() {
|
||||
Ok(i) => Ok(f32::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read Double as f64
|
||||
fn read_double(&mut self) -> Result<f64, ProtocolError> {
|
||||
match self.read_bytes(8)?.try_into() {
|
||||
Ok(i) => Ok(f64::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read Int as i32
|
||||
fn read_int(&mut self) -> Result<i32, ProtocolError> {
|
||||
match self.read_bytes(4)?.try_into() {
|
||||
Ok(i) => Ok(i32::from_be_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
/// Read UUID
|
||||
fn read_uuid(&mut self) -> Result<Uuid, ProtocolError> {
|
||||
match self.read_bytes(16)?.try_into() {
|
||||
Ok(i) => Ok(Uuid::from_bytes(i)),
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
|
||||
/// Read VarInt as usize with size in bytes (varint, size)
|
||||
fn read_usize_varint_size(&mut self) -> Result<(usize, usize), ProtocolError> {
|
||||
size_varint!(usize, self)
|
||||
}
|
||||
/// Read VarInt as u8 with size in bytes (varint, size)
|
||||
fn read_u8_varint_size(&mut self) -> Result<(u8, usize), ProtocolError> {
|
||||
size_varint!(u8, self)
|
||||
}
|
||||
/// Read VarInt as u16 with size in bytes (varint, size)
|
||||
fn read_u16_varint_size(&mut self) -> Result<(u16, usize), ProtocolError> {
|
||||
size_varint!(u16, self)
|
||||
}
|
||||
/// Read VarInt as u32 with size in bytes (varint, size)
|
||||
fn read_u32_varint_size(&mut self) -> Result<(u32, usize), ProtocolError> {
|
||||
size_varint!(u32, self)
|
||||
}
|
||||
/// Read VarInt as u64 with size in bytes (varint, size)
|
||||
fn read_u64_varint_size(&mut self) -> Result<(u64, usize), ProtocolError> {
|
||||
size_varint!(u64, self)
|
||||
}
|
||||
/// Read VarInt as u128 with size in bytes (varint, size)
|
||||
fn read_u128_varint_size(&mut self) -> Result<(u128, usize), ProtocolError> {
|
||||
size_varint!(u128, self)
|
||||
}
|
||||
|
||||
/// Read VarInt as isize with size in bytes (varint, size)
|
||||
fn read_isize_varint_size(&mut self) -> Result<(isize, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_usize_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
/// Read VarInt as i8 with size in bytes (varint, size)
|
||||
fn read_i8_varint_size(&mut self) -> Result<(i8, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_u8_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
/// Read VarInt as i16 with size in bytes (varint, size)
|
||||
fn read_i16_varint_size(&mut self) -> Result<(i16, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_u16_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
/// Read VarInt as i32 with size in bytes (varint, size)
|
||||
fn read_i32_varint_size(&mut self) -> Result<(i32, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_u32_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
/// Read VarInt as i64 with size in bytes (varint, size)
|
||||
fn read_i64_varint_size(&mut self) -> Result<(i64, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_u64_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
/// Read VarInt as i128 with size in bytes (varint, size)
|
||||
fn read_i128_varint_size(&mut self) -> Result<(i128, usize), ProtocolError> {
|
||||
Ok({
|
||||
let i = self.read_u128_varint_size()?;
|
||||
(i.0.zigzag(), i.1)
|
||||
})
|
||||
}
|
||||
|
||||
/// Read VarInt as usize
|
||||
fn read_usize_varint(&mut self) -> Result<usize, ProtocolError> {
|
||||
read_varint!(usize, self)
|
||||
}
|
||||
/// Read VarInt as u8
|
||||
fn read_u8_varint(&mut self) -> Result<u8, ProtocolError> {
|
||||
read_varint!(u8, self)
|
||||
}
|
||||
/// Read VarInt as u16
|
||||
fn read_u16_varint(&mut self) -> Result<u16, ProtocolError> {
|
||||
read_varint!(u16, self)
|
||||
}
|
||||
/// Read VarInt as u32
|
||||
fn read_u32_varint(&mut self) -> Result<u32, ProtocolError> {
|
||||
read_varint!(u32, self)
|
||||
}
|
||||
/// Read VarInt as u64
|
||||
fn read_u64_varint(&mut self) -> Result<u64, ProtocolError> {
|
||||
read_varint!(u64, self)
|
||||
}
|
||||
/// Read VarInt as u128
|
||||
fn read_u128_varint(&mut self) -> Result<u128, ProtocolError> {
|
||||
read_varint!(u128, self)
|
||||
}
|
||||
|
||||
/// Read VarInt as isize
|
||||
fn read_isize_varint(&mut self) -> Result<isize, ProtocolError> {
|
||||
Ok(self.read_usize_varint()?.zigzag())
|
||||
}
|
||||
/// Read VarInt as i8
|
||||
fn read_i8_varint(&mut self) -> Result<i8, ProtocolError> {
|
||||
Ok(self.read_u8_varint()?.zigzag())
|
||||
}
|
||||
/// Read VarInt as i16
|
||||
fn read_i16_varint(&mut self) -> Result<i16, ProtocolError> {
|
||||
Ok(self.read_u16_varint()?.zigzag())
|
||||
}
|
||||
/// Read VarInt as i32
|
||||
fn read_i32_varint(&mut self) -> Result<i32, ProtocolError> {
|
||||
Ok(self.read_u32_varint()?.zigzag())
|
||||
}
|
||||
/// Read VarInt as i64
|
||||
fn read_i64_varint(&mut self) -> Result<i64, ProtocolError> {
|
||||
Ok(self.read_u64_varint()?.zigzag())
|
||||
}
|
||||
/// Read VarInt as i128
|
||||
fn read_i128_varint(&mut self) -> Result<i128, ProtocolError> {
|
||||
Ok(self.read_u128_varint()?.zigzag())
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: Read> DataReader for R {
|
||||
fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError> {
|
||||
let mut buf = vec![0; size];
|
||||
match self.read(&mut buf) {
|
||||
Ok(i) => if i == size {
|
||||
Ok(buf)
|
||||
} else if i == 0 {
|
||||
Err(ProtocolError::ConnectionClosedError)
|
||||
} else {
|
||||
buf.truncate(i);
|
||||
buf.append(&mut self.read_bytes(size-i)?);
|
||||
Ok(buf)
|
||||
},
|
||||
Err(_) => Err(ProtocolError::ReadError),
|
||||
}
|
||||
}
|
||||
}
|
||||
70
src/data/varint.rs
Executable file
70
src/data/varint.rs
Executable file
|
|
@ -0,0 +1,70 @@
|
|||
macro_rules! size_varint {
|
||||
($type:ty, $self:expr) => {{
|
||||
let mut shift: $type = 0;
|
||||
let mut decoded: $type = 0;
|
||||
let mut size: usize = 0;
|
||||
|
||||
loop {
|
||||
let next = DataReader::read_byte($self)?;
|
||||
size += 1;
|
||||
|
||||
if shift >= (std::mem::size_of::<$type>() * 8) as $type {
|
||||
return Err(ProtocolError::VarIntError);
|
||||
}
|
||||
|
||||
decoded |= ((next & 0b01111111) as $type) << shift;
|
||||
|
||||
if next & 0b10000000 == 0b10000000 {
|
||||
shift += 7;
|
||||
} else {
|
||||
return Ok((decoded, size));
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
macro_rules! read_varint {
|
||||
($type:ty, $self:expr) => {{
|
||||
let mut shift: $type = 0;
|
||||
let mut decoded: $type = 0;
|
||||
|
||||
loop {
|
||||
let next = DataReader::read_byte($self)?;
|
||||
|
||||
if shift >= (std::mem::size_of::<$type>() * 8) as $type {
|
||||
return Err(ProtocolError::VarIntError);
|
||||
}
|
||||
|
||||
decoded |= ((next & 0b01111111) as $type) << shift;
|
||||
|
||||
if next & 0b10000000 == 0b10000000 {
|
||||
shift += 7;
|
||||
} else {
|
||||
return Ok(decoded);
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
macro_rules! write_varint {
|
||||
($type:ty, $self:expr, $value:expr) => {{
|
||||
let mut value: $type = $value;
|
||||
|
||||
if value == 0 {
|
||||
DataWriter::write_byte($self, 0)
|
||||
} else {
|
||||
while value >= 0b10000000 {
|
||||
let next: u8 = ((value & 0b01111111) as u8) | 0b10000000;
|
||||
value >>= 7;
|
||||
|
||||
DataWriter::write_byte($self, next)?;
|
||||
}
|
||||
|
||||
DataWriter::write_byte($self, (value & 0b01111111) as u8)
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
pub(crate) use read_varint;
|
||||
pub(crate) use size_varint;
|
||||
pub(crate) use write_varint;
|
||||
132
src/data/writer.rs
Executable file
132
src/data/writer.rs
Executable file
|
|
@ -0,0 +1,132 @@
|
|||
use crate::{data::varint::write_varint, zigzag::Zigzag, ProtocolError};
|
||||
use std::io::Write;
|
||||
use uuid::Uuid;
|
||||
|
||||
/// Packet data writer trait
|
||||
pub trait DataWriter {
|
||||
/// Write bytes
|
||||
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError>;
|
||||
|
||||
/// Write byte
|
||||
fn write_byte(&mut self, byte: u8) -> Result<(), ProtocolError> {
|
||||
self.write_bytes(&[byte])
|
||||
}
|
||||
/// Write String
|
||||
fn write_string(&mut self, val: &str) -> Result<(), ProtocolError> {
|
||||
let bytes = val.as_bytes();
|
||||
self.write_usize_varint(bytes.len())?;
|
||||
self.write_bytes(bytes)
|
||||
}
|
||||
/// Write UUID
|
||||
fn write_uuid(&mut self, val: &Uuid) -> Result<(), ProtocolError> {
|
||||
self.write_bytes(val.as_bytes())
|
||||
}
|
||||
/// Write Unsigned Short as u16
|
||||
fn write_unsigned_short(&mut self, val: u16) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Boolean
|
||||
fn write_boolean(&mut self, val: bool) -> Result<(), ProtocolError> {
|
||||
match self.write_byte(if val { 0x01 } else { 0x00 }) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Short as i16
|
||||
fn write_short(&mut self, val: i16) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Long as i64
|
||||
fn write_long(&mut self, val: i64) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Float as f32
|
||||
fn write_float(&mut self, val: f32) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Double as f64
|
||||
fn write_double(&mut self, val: f64) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
/// Write Int as i32
|
||||
fn write_int(&mut self, val: i32) -> Result<(), ProtocolError> {
|
||||
match self.write_bytes(&val.to_be_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::UnsignedShortError),
|
||||
}
|
||||
}
|
||||
|
||||
/// Write VarInt as usize
|
||||
fn write_usize_varint(&mut self, val: usize) -> Result<(), ProtocolError> {
|
||||
write_varint!(usize, self, val)
|
||||
}
|
||||
/// Write VarInt as u8
|
||||
fn write_u8_varint(&mut self, val: u8) -> Result<(), ProtocolError> {
|
||||
write_varint!(u8, self, val)
|
||||
}
|
||||
/// Write VarInt as u16
|
||||
fn write_u16_varint(&mut self, val: u16) -> Result<(), ProtocolError> {
|
||||
write_varint!(u16, self, val)
|
||||
}
|
||||
/// Write VarInt as u32
|
||||
fn write_u32_varint(&mut self, val: u32) -> Result<(), ProtocolError> {
|
||||
write_varint!(u32, self, val)
|
||||
}
|
||||
/// Write VarInt as u64
|
||||
fn write_u64_varint(&mut self, val: u64) -> Result<(), ProtocolError> {
|
||||
write_varint!(u64, self, val)
|
||||
}
|
||||
/// Write VarInt as u128
|
||||
fn write_u128_varint(&mut self, val: u128) -> Result<(), ProtocolError> {
|
||||
write_varint!(u128, self, val)
|
||||
}
|
||||
|
||||
/// Write VarInt as isize
|
||||
fn write_isize_varint(&mut self, val: isize) -> Result<(), ProtocolError> {
|
||||
self.write_usize_varint(val.zigzag())
|
||||
}
|
||||
/// Write VarInt as i8
|
||||
fn write_i8_varint(&mut self, val: i8) -> Result<(), ProtocolError> {
|
||||
self.write_u8_varint(val.zigzag())
|
||||
}
|
||||
/// Write VarInt as i16
|
||||
fn write_i16_varint(&mut self, val: i16) -> Result<(), ProtocolError> {
|
||||
self.write_u16_varint(val.zigzag())
|
||||
}
|
||||
/// Write VarInt as i32
|
||||
fn write_i32_varint(&mut self, val: i32) -> Result<(), ProtocolError> {
|
||||
self.write_u32_varint(val.zigzag())
|
||||
}
|
||||
/// Write VarInt as i64
|
||||
fn write_i64_varint(&mut self, val: i64) -> Result<(), ProtocolError> {
|
||||
self.write_u64_varint(val.zigzag())
|
||||
}
|
||||
/// Write VarInt as i128
|
||||
fn write_i128_varint(&mut self, val: i128) -> Result<(), ProtocolError> {
|
||||
self.write_u128_varint(val.zigzag())
|
||||
}
|
||||
}
|
||||
|
||||
impl<W: Write> DataWriter for W {
|
||||
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError> {
|
||||
match self.write_all(bytes) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(_) => Err(ProtocolError::WriteError),
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue