diff options
Diffstat (limited to 'minecraft-protocol/src/packets')
4 files changed, 112 insertions, 26 deletions
diff --git a/minecraft-protocol/src/packets/handshake/client_intention_packet.rs b/minecraft-protocol/src/packets/handshake/client_intention_packet.rs index 7dd358eb..401dbbac 100644 --- a/minecraft-protocol/src/packets/handshake/client_intention_packet.rs +++ b/minecraft-protocol/src/packets/handshake/client_intention_packet.rs @@ -1,5 +1,8 @@ use std::hash::Hash; +use async_trait::async_trait; +use tokio::io::BufReader; + use crate::{ mc_buf, packets::{ConnectionProtocol, Packet, PacketTrait}, @@ -14,9 +17,10 @@ pub struct ClientIntentionPacket<'a> { pub intention: ConnectionProtocol, } +#[async_trait] impl<'a> PacketTrait for ClientIntentionPacket<'a> { fn get(&self) -> Packet { - Packet::ClientIntentionPacket(self) + Packet::ClientIntentionPacket(*self) } fn write(&self, buf: &mut Vec<u8>) { @@ -26,5 +30,10 @@ impl<'a> PacketTrait for ClientIntentionPacket<'a> { mc_buf::write_varint(buf, self.intention.clone() as i32); } - fn parse<T: tokio::io::AsyncRead + std::marker::Unpin>(&self, buf: T) -> () {} + async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + buf: &mut BufReader<T>, + ) -> Result<Packet<'_>, String> { + Err("ClientIntentionPacket::parse not implemented".to_string()) + // Ok(ClientIntentionPacket {}.get()) + } } diff --git a/minecraft-protocol/src/packets/mod.rs b/minecraft-protocol/src/packets/mod.rs index 5fb34743..76f9128e 100644 --- a/minecraft-protocol/src/packets/mod.rs +++ b/minecraft-protocol/src/packets/mod.rs @@ -1,10 +1,12 @@ -mod game; -mod handshake; -mod login; -mod status; +pub mod game; +pub mod handshake; +pub mod login; +pub mod status; use async_trait::async_trait; -use tokio::io::AsyncRead; +use tokio::io::{AsyncRead, BufReader}; + +use crate::connection::PacketFlow; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ConnectionProtocol { @@ -16,24 +18,89 @@ pub enum ConnectionProtocol { pub enum Packet<'a> { // game + // handshake - ClientIntentionPacket(&'a handshake::client_intention_packet::ClientIntentionPacket<'a>), + ClientIntentionPacket(handshake::client_intention_packet::ClientIntentionPacket<'a>), + // login + // status ServerboundStatusRequestPacket( - &'a status::serverbound_status_request_packet::ServerboundStatusRequestPacket, + status::serverbound_status_request_packet::ServerboundStatusRequestPacket, ), - ClientboundStatusRequestPacket( - &'a status::clientbound_status_response_packet::ClientboundStatusRequestPacket, + ClientboundStatusResponsePacket( + status::clientbound_status_response_packet::ClientboundStatusResponsePacket, ), } +// TODO: do all this with macros so it's less repetitive +impl Packet<'_> { + fn get_inner_packet(&self) -> &dyn PacketTrait { + match self { + Packet::ClientIntentionPacket(packet) => packet, + Packet::ServerboundStatusRequestPacket(packet) => packet, + Packet::ClientboundStatusResponsePacket(packet) => packet, + } + } + + pub fn id(&self) -> u32 { + match self { + Packet::ClientIntentionPacket(packet) => 0x00, + Packet::ServerboundStatusRequestPacket(packet) => 0x00, + Packet::ClientboundStatusResponsePacket(packet) => 0x00, + } + } + + /// Read a packet by its id, ConnectionProtocol, and flow + pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + id: u32, + protocol: ConnectionProtocol, + flow: PacketFlow, + buf: &mut BufReader<T>, + ) -> Result<Packet<'_>, String> { + match protocol { + ConnectionProtocol::Handshake => match id { + 0x00 => Ok( + handshake::client_intention_packet::ClientIntentionPacket::read(buf).await?, + ), + _ => Err(format!("Unknown packet id: {}", id)), + }, + ConnectionProtocol::Game => Err("Game protocol not implemented yet".to_string()), + ConnectionProtocol::Status => match flow { + PacketFlow::ServerToClient => match id { + 0x00 => Ok( + status::clientbound_status_response_packet::ClientboundStatusResponsePacket + ::read(buf) + .await?, + ), + _ => Err(format!("Unknown packet id: {}", id)), + }, + PacketFlow::ClientToServer => match id { + 0x00 => Ok( + status::serverbound_status_request_packet::ServerboundStatusRequestPacket + ::read(buf) + .await?, + ), + _ => Err(format!("Unknown packet id: {}", id)), + }, + }, + ConnectionProtocol::Login => Err("Login protocol not implemented yet".to_string()), + } + } + + pub fn write(&self, buf: &mut Vec<u8>) { + self.get_inner_packet().write(buf); + } +} + +#[async_trait] pub trait PacketTrait { /// Return a version of the packet that you can actually use for stuff fn get(&self) -> Packet; fn write(&self, buf: &mut Vec<u8>) -> (); - fn parse<T: AsyncRead + std::marker::Unpin>( - buf: &mut T, - // is using a static lifetime here a good idea? idk - ) -> Result<Packet<'_>, String>; + async fn read<T: AsyncRead + std::marker::Unpin + std::marker::Send>( + buf: &mut BufReader<T>, + ) -> Result<Packet<'_>, String> + where + Self: Sized; } diff --git a/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs b/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs index ada86667..38747cc8 100644 --- a/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs +++ b/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs @@ -1,28 +1,31 @@ use async_trait::async_trait; use std::hash::Hash; +use tokio::io::BufReader; use crate::{ mc_buf, packets::{Packet, PacketTrait}, }; -#[derive(Hash)] -pub struct ClientboundStatusRequestPacket { +#[derive(Hash, Clone)] +pub struct ClientboundStatusResponsePacket { status: String, } -impl PacketTrait for ClientboundStatusRequestPacket { +#[async_trait] +impl PacketTrait for ClientboundStatusResponsePacket { fn get(&self) -> Packet { - Packet::ClientboundStatusRequestPacket(self) + Packet::ClientboundStatusResponsePacket(self.clone()) } fn write(&self, _buf: &mut Vec<u8>) {} - fn parse<T: tokio::io::AsyncRead + std::marker::Unpin>( - buf: &mut T, + async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + buf: &mut BufReader<T>, ) -> Result<Packet<'_>, String> { - let status = mc_buf::read_utf(&mut buf).await?; + let status = mc_buf::read_utf(buf).await?; // this.status = GsonHelper.fromJson(GSON, friendlyByteBuf.readUtf(32767), ServerStatus.class); - Ok(ClientboundStatusRequestPacket { status }.get()) + let packet = ClientboundStatusResponsePacket { status }.get(); + Ok(packet) } } diff --git a/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs b/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs index f2e6fe9a..b3c87968 100644 --- a/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs +++ b/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs @@ -1,4 +1,6 @@ +use async_trait::async_trait; use std::hash::Hash; +use tokio::io::BufReader; use crate::{ mc_buf, @@ -8,11 +10,16 @@ use crate::{ #[derive(Hash)] pub struct ServerboundStatusRequestPacket {} -// implement "Packet" for "ClientIntentionPacket" +#[async_trait] impl PacketTrait for ServerboundStatusRequestPacket { fn get(&self) -> Packet { - Packet::ServerboundStatusRequestPacket(self) + Packet::ServerboundStatusRequestPacket(*self) } fn write(&self, _buf: &mut Vec<u8>) {} - fn parse<T: tokio::io::AsyncRead + std::marker::Unpin>(&self, buf: T) -> () {} + + async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + buf: &mut BufReader<T>, + ) -> Result<Packet<'_>, String> { + Err("ServerboundStatusRequestPacket::read not implemented".to_string()) + } } |