read exact size of packets, fixing networking buf

src/packet.rs

@@ -1,4 +1,5 @@
 use half::f16;
+use safer_bytes::{error::Truncated, SafeBuf};
 
 pub mod client;
 pub mod server;
@@ -10,79 +11,30 @@ pub const ARRAY_LENGTH: usize = 1024;
 /// units in an f16 unit
 pub const F16_UNITS: f32 = 32.0;
 
-/// helper for reading packets
-#[derive(Debug)]
-pub struct PacketReader<'p> {
-	raw_packet: &'p [u8],
-	cursor: usize,
+/// trait extending the `SafeBuf` type
+pub trait SafeBufExtension: SafeBuf {
+	/// tries to get the next f16 in the buffer
+	fn try_get_f16(&mut self) -> Result<f16, Truncated>;
+	/// tries to get the next string in the buffer
+	fn try_get_string(&mut self) -> Result<String, Truncated>;
 }
 
-impl<'p> PacketReader<'p> {
-	/// creates a new packet reader from the given packet data
-	pub fn new(raw_packet: &'p [u8]) -> Self {
-		Self {
-			raw_packet,
-			cursor: 0,
-		}
+impl<T> SafeBufExtension for T
+where
+	T: SafeBuf,
+{
+	fn try_get_f16(&mut self) -> Result<f16, Truncated> {
+		self.try_get_i16()
+			.map(|v| f16::from_f32(v as f32 / F16_UNITS))
 	}
 
-	/// gets the next u8 in the packet, if any
-	fn next_u8(&mut self) -> Option<u8> {
-		let r = self.raw_packet.get(self.cursor).copied();
-		self.cursor = self.cursor.checked_add(1).unwrap_or(self.cursor);
-		r
-	}
-
-	/// gets the next i8 in the packet, if any
-	fn next_i8(&mut self) -> Option<i8> {
-		self.next_u8().map(|b| b as i8)
-	}
-
-	/// gets the next u16 in the packet, if any
-	fn next_u16(&mut self) -> Option<u16> {
-		Some(u16::from_be_bytes([self.next_u8()?, self.next_u8()?]))
-	}
-
-	/// gets the next i16 in the packet, if any
-	fn next_i16(&mut self) -> Option<i16> {
-		self.next_u16().map(|s| s as i16)
-	}
-
-	/// gets the next f16 in the packet, if any
-	fn next_f16(&mut self) -> Option<f16> {
-		self.next_i16().map(|v| f16::from_f32(v as f32 / F16_UNITS))
-	}
-
-	/// gets the next string in the packet, if any
-	fn next_string(&mut self) -> Option<String> {
+	fn try_get_string(&mut self) -> Result<String, Truncated> {
 		let mut chars: Vec<char> = Vec::new();
 		for _ in 0..STRING_LENGTH {
-			chars.push(self.next_u8()? as char);
+			chars.push(self.try_get_u8()? as char);
 		}
-		Some(String::from_iter(chars).trim().to_string())
+		Ok(String::from_iter(chars).trim().to_string())
 	}
-
-	// /// gets the next array of the given length in the packet, if any
-	// fn next_array_of_length(&mut self, len: usize) -> Option<Vec<u8>> {
-	// 	let mut bytes: Vec<u8> = Vec::new();
-	// 	let mut append = true;
-	// 	for _ in 0..len {
-	// 		let b = self.next_u8()?;
-	// 		if append {
-	// 			if b == 0 {
-	// 				append = false;
-	// 			} else {
-	// 				bytes.push(b);
-	// 			}
-	// 		}
-	// 	}
-	// 	Some(bytes)
-	// }
-
-	// /// gets the next array of default size in the packet, if any
-	// fn next_array(&mut self) -> Option<Vec<u8>> {
-	// 	self.next_array_of_length(ARRAY_LENGTH)
-	// }
 }
 
 /// helper for writing a packet

src/packet/client.rs

@@ -1,5 +1,7 @@
 use half::f16;
 
+use super::{SafeBufExtension, STRING_LENGTH};
+
 /// enum for a packet which can be received by the client
 #[derive(Debug, Clone)]
 pub enum ClientPacket {
@@ -53,35 +55,52 @@ impl ClientPacket {
 	// 	}
 	// }
 
+	/// gets the size of the packet from the given id (minus one byte for the id)
+	pub const fn get_size_from_id(id: u8) -> Option<usize> {
+		Some(match id {
+			0x00 => 1 + STRING_LENGTH + STRING_LENGTH + 1,
+			0x05 => 2 + 2 + 2 + 1 + 1,
+			0x08 => 1 + 2 + 2 + 2 + 1 + 1,
+			0x0d => 1 + STRING_LENGTH,
+			_ => return None,
+		})
+	}
+
 	/// reads the packet
-	pub fn read(id: u8, packet: &mut super::PacketReader) -> Option<Self> {
+	pub fn read<B>(id: u8, buf: &mut B) -> Option<Self>
+	where
+		B: SafeBufExtension,
+	{
 		Some(match id {
 			0x00 => Self::PlayerIdentification {
-				protocol_version: packet.next_u8()?,
-				username: packet.next_string()?,
-				verification_key: packet.next_string()?,
-				_unused: packet.next_u8()?,
+				protocol_version: buf.try_get_u8().ok()?,
+				username: buf.try_get_string().ok()?,
+				verification_key: buf.try_get_string().ok()?,
+				_unused: buf.try_get_u8().ok()?,
 			},
 			0x05 => Self::SetBlock {
-				x: packet.next_i16()?,
-				y: packet.next_i16()?,
-				z: packet.next_i16()?,
-				mode: packet.next_u8()?,
-				block_type: packet.next_u8()?,
+				x: buf.try_get_i16().ok()?,
+				y: buf.try_get_i16().ok()?,
+				z: buf.try_get_i16().ok()?,
+				mode: buf.try_get_u8().ok()?,
+				block_type: buf.try_get_u8().ok()?,
 			},
 			0x08 => Self::PositionOrientation {
-				_player_id: packet.next_i8()?,
-				x: packet.next_f16()?,
-				y: packet.next_f16()?,
-				z: packet.next_f16()?,
-				yaw: packet.next_u8()?,
-				pitch: packet.next_u8()?,
+				_player_id: buf.try_get_i8().ok()?,
+				x: buf.try_get_f16().ok()?,
+				y: buf.try_get_f16().ok()?,
+				z: buf.try_get_f16().ok()?,
+				yaw: buf.try_get_u8().ok()?,
+				pitch: buf.try_get_u8().ok()?,
 			},
 			0x0d => Self::Message {
-				player_id: packet.next_i8()?,
-				message: packet.next_string()?,
+				player_id: buf.try_get_i8().ok()?,
+				message: buf.try_get_string().ok()?,
 			},
-			_ => return None,
+			id => {
+				println!("unknown packet id: {id:0x}");
+				return None;
+			}
 		})
 	}
 

src/server/network.rs

@@ -1,18 +1,17 @@
 use std::{collections::VecDeque, io::Write, net::SocketAddr, sync::Arc};
 
+use bytes::BytesMut;
 use flate2::{write::GzEncoder, Compression};
 use half::f16;
 use tokio::{
-	io::{AsyncWriteExt, Interest},
+	io::{AsyncReadExt, AsyncWriteExt, Interest},
 	net::TcpStream,
 	sync::RwLock,
 };
 
 use crate::{
 	level::{block::BLOCK_INFO, Level},
-	packet::{
-		client::ClientPacket, server::ServerPacket, PacketReader, PacketWriter, ARRAY_LENGTH,
-	},
+	packet::{client::ClientPacket, server::ServerPacket, PacketWriter, ARRAY_LENGTH},
 	player::{Player, PlayerType},
 	server::config::ServerProtectionMode,
 };
@@ -69,11 +68,9 @@ async fn handle_stream_inner(
 	data: Arc<RwLock<ServerData>>,
 	own_id: &mut i8,
 ) -> std::io::Result<Option<String>> {
-	const BUF_SIZE: usize = 130;
-
 	let mut reply_queue: VecDeque<ServerPacket> = VecDeque::new();
-	let mut packet_buf = [0u8];
 	let mut read_buf;
+	let mut id_buf;
 
 	loop {
 		let ready = stream
@@ -86,20 +83,18 @@ async fn handle_stream_inner(
 		}
 
 		if ready.is_readable() {
-			match stream.try_read(&mut packet_buf) {
+			id_buf = [0u8];
+			match stream.try_read(&mut id_buf) {
 				Ok(n) => {
 					if n == 1 {
-						read_buf = [0; BUF_SIZE];
-						match stream.try_read(&mut read_buf) {
-							Ok(_n) => {}
-							Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
-							Err(e) => return Err(e),
-						}
+						if let Some(size) = ClientPacket::get_size_from_id(id_buf[0]) {
+							read_buf = BytesMut::zeroed(size);
 
-						let mut reader = PacketReader::new(&read_buf);
+							stream.read_exact(&mut read_buf).await?;
 
-						if let Some(packet) = ClientPacket::read(packet_buf[0], &mut reader) {
-							match packet {
+							match ClientPacket::read(id_buf[0], &mut read_buf)
+								.expect("should never fail: id already checked")
+							{
 								ClientPacket::PlayerIdentification {
 									protocol_version,
 									username,
@@ -331,7 +326,7 @@ async fn handle_stream_inner(
 								}
 							}
 						} else {
-							println!("unknown packet id: {:0x}", packet_buf[0]);
+							println!("unknown packet id: {}", id_buf[0]);
 						}
 					}
 				}