diff options
Diffstat (limited to 'minecraft-protocol/src/packets')
9 files changed, 283 insertions, 82 deletions
diff --git a/minecraft-protocol/src/packets/game/mod.rs b/minecraft-protocol/src/packets/game/mod.rs index 8b137891..08444697 100644 --- a/minecraft-protocol/src/packets/game/mod.rs +++ b/minecraft-protocol/src/packets/game/mod.rs @@ -1 +1,2 @@ - +#[derive(Clone, Debug)] +pub enum GamePacket {} diff --git a/minecraft-protocol/src/packets/handshake/mod.rs b/minecraft-protocol/src/packets/handshake/mod.rs index 667b00f2..d2716299 100644 --- a/minecraft-protocol/src/packets/handshake/mod.rs +++ b/minecraft-protocol/src/packets/handshake/mod.rs @@ -1 +1,6 @@ pub mod client_intention_packet; + +#[derive(Clone, Debug)] +pub enum HandshakePacket { + ClientIntentionPacket(client_intention_packet::ClientIntentionPacket), +} diff --git a/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs b/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs new file mode 100644 index 00000000..878ca456 --- /dev/null +++ b/minecraft-protocol/src/packets/login/clientbound_hello_packet.rs @@ -0,0 +1,40 @@ +use async_trait::async_trait; +use std::hash::Hash; +use tokio::io::BufReader; + +use crate::{ + mc_buf, + packets::{Packet, PacketTrait}, +}; + +#[derive(Hash, Clone, Debug)] +pub struct ClientboundHelloPacket { + pub server_id: String, + pub public_key: Vec<u8>, + pub nonce: Vec<u8>, +} + +#[async_trait] +impl PacketTrait for ClientboundHelloPacket { + fn get(self) -> Packet { + Packet::ClientboundHelloPacket(self) + } + fn write(&self, _buf: &mut Vec<u8>) { + panic!("ClientboundHelloPacket::write not implemented") + } + + async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + buf: &mut BufReader<T>, + ) -> Result<Packet, String> { + let server_id = mc_buf::read_utf_with_len(buf, 20).await?; + let public_key = mc_buf::read_byte_array(buf).await?; + let nonce = mc_buf::read_byte_array(buf).await?; + + Ok(ClientboundHelloPacket { + server_id, + public_key, + nonce, + } + .get()) + } +} diff --git a/minecraft-protocol/src/packets/login/mod.rs b/minecraft-protocol/src/packets/login/mod.rs index 8b137891..47193f92 100644 --- a/minecraft-protocol/src/packets/login/mod.rs +++ b/minecraft-protocol/src/packets/login/mod.rs @@ -1 +1,8 @@ +pub mod clientbound_hello_packet; +pub mod serverbound_hello_packet; +#[derive(Clone, Debug)] +pub enum LoginPacket { + ServerboundHelloPacket(serverbound_hello_packet::ServerboundHelloPacket), + ClientboundHelloPacket(clientbound_hello_packet::ClientboundHelloPacket), +} diff --git a/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs b/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs new file mode 100644 index 00000000..cadf9f7b --- /dev/null +++ b/minecraft-protocol/src/packets/login/serverbound_hello_packet.rs @@ -0,0 +1,29 @@ +use async_trait::async_trait; +use std::hash::Hash; +use tokio::io::BufReader; + +use crate::{ + mc_buf, + packets::{Packet, PacketTrait}, +}; + +#[derive(Hash, Clone, Debug)] +pub struct ServerboundHelloPacket { + pub username: String, +} + +#[async_trait] +impl PacketTrait for ServerboundHelloPacket { + fn get(self) -> Packet { + Packet::ServerboundHelloPacket(self) + } + fn write(&self, buf: &mut Vec<u8>) { + mc_buf::write_utf(buf, &self.username); + } + + async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + _buf: &mut BufReader<T>, + ) -> Result<Packet, String> { + Err("ServerboundHelloPacket::read not implemented".to_string()) + } +} diff --git a/minecraft-protocol/src/packets/mod.rs b/minecraft-protocol/src/packets/mod.rs index bacd0c27..46caf02b 100644 --- a/minecraft-protocol/src/packets/mod.rs +++ b/minecraft-protocol/src/packets/mod.rs @@ -6,7 +6,9 @@ pub mod status; use async_trait::async_trait; use tokio::io::{AsyncRead, BufReader}; -use crate::connection::PacketFlow; +use crate::connect::PacketFlow; + +pub const PROTOCOL_VERSION: u32 = 757; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum ConnectionProtocol { @@ -18,90 +20,123 @@ pub enum ConnectionProtocol { #[derive(Clone, Debug)] pub enum Packet { - // game - - // handshake - ClientIntentionPacket(handshake::client_intention_packet::ClientIntentionPacket), - - // login - - // status - ServerboundStatusRequestPacket( - status::serverbound_status_request_packet::ServerboundStatusRequestPacket, - ), - ClientboundStatusResponsePacket( - status::clientbound_status_response_packet::ClientboundStatusResponsePacket, - ), + Game(game::GamePacket), + Handshake(handshake::HandshakePacket), + Login(login::LoginPacket), + Status(status::StatusPacket), } -// 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, - } - } +#[async_trait] +pub trait ProtocolPacket { + fn get_inner<P: PacketTrait>(&self) -> &P; + + fn id(&self) -> u32; /// Read a packet by its id, ConnectionProtocol, and flow - pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( + async fn read< + T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send, + P: ProtocolPacket, + >( 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); - } + ) -> Result<P, String> + where + Self: Sized; + + fn write(&self, buf: &mut Vec<u8>); } +// impl Packet { +// fn get_inner_packet(&self) -> &dyn PacketTrait { +// match self { +// Packet::ClientIntentionPacket(packet) => packet, +// Packet::ServerboundStatusRequestPacket(packet) => packet, +// Packet::ClientboundStatusResponsePacket(packet) => packet, +// Packet::ServerboundHelloPacket(packet) => packet, +// Packet::ClientboundHelloPacket(packet) => packet, +// } +// } + +// pub fn id(&self) -> u32 { +// match self { +// Packet::ClientIntentionPacket(_packet) => 0x00, +// Packet::ServerboundStatusRequestPacket(_packet) => 0x00, +// Packet::ClientboundStatusResponsePacket(_packet) => 0x00, +// Packet::ServerboundHelloPacket(_packet) => 0x00, +// Packet::ClientboundHelloPacket(_packet) => 0x01, +// } +// } + +// /// 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 flow { +// PacketFlow::ClientToServer => match id { +// 0x00 => Ok( +// handshake::client_intention_packet::ClientIntentionPacket::read(buf).await?, +// ), +// _ => Err(format!("Unknown ClientToServer handshake packet id: {}", id)), +// } +// PacketFlow::ServerToClient => Err("ServerToClient handshake packets not implemented".to_string()), +// }, + +// 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 ServerToClient status packet id: {}", id)), +// }, +// PacketFlow::ClientToServer => match id { +// 0x00 => Ok( +// status::serverbound_status_request_packet::ServerboundStatusRequestPacket +// ::read(buf) +// .await?, +// ), +// _ => Err(format!("Unknown ClientToServer status packet id: {}", id)), +// }, +// }, + +// ConnectionProtocol::Login => match flow { +// PacketFlow::ServerToClient => match id { +// 0x01 => Ok( +// login::clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?, +// ), +// _ => Err(format!("Unknown ServerToClient login packet id: {}", id)), +// }, +// PacketFlow::ClientToServer => match id { +// 0x00 => Ok( +// login::serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?, +// ), +// _ => Err(format!("Unknown ClientToServer login packet id: {}", id)), +// }, +// }, +// } +// } + +// 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 get<P: ProtocolPacket>(self) -> P; fn write(&self, buf: &mut Vec<u8>); - async fn read<T: AsyncRead + std::marker::Unpin + std::marker::Send>( + async fn read<T: AsyncRead + std::marker::Unpin + std::marker::Send, P: ProtocolPacket>( buf: &mut BufReader<T>, - ) -> Result<Packet, String> + ) -> Result<P, 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 99bef586..30b1403c 100644 --- a/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs +++ b/minecraft-protocol/src/packets/status/clientbound_status_response_packet.rs @@ -9,9 +9,11 @@ use crate::{ packets::{Packet, PacketTrait}, }; +use super::StatusPacket; + #[derive(Clone, Debug, Deserialize)] pub struct Version { - pub name: String, + pub name: Component, pub protocol: u32, } @@ -31,14 +33,16 @@ pub struct Players { // the entire packet is just json, which is why it has deserialize #[derive(Clone, Debug, Deserialize)] pub struct ClientboundStatusResponsePacket { - pub version: Version, pub description: Component, + pub favicon: Option<String>, + pub players: Players, + pub version: Version, } #[async_trait] impl PacketTrait for ClientboundStatusResponsePacket { - fn get(self) -> Packet { - Packet::ClientboundStatusResponsePacket(self) + fn get(self) -> StatusPacket { + StatusPacket::ClientboundStatusResponsePacket(self) } fn write(&self, _buf: &mut Vec<u8>) {} diff --git a/minecraft-protocol/src/packets/status/mod.rs b/minecraft-protocol/src/packets/status/mod.rs index efc03631..7e327ca7 100644 --- a/minecraft-protocol/src/packets/status/mod.rs +++ b/minecraft-protocol/src/packets/status/mod.rs @@ -1,2 +1,80 @@ pub mod clientbound_status_response_packet; pub mod serverbound_status_request_packet; + +use async_trait::async_trait; +use tokio::io::BufReader; + +use crate::connect::PacketFlow; + +use super::{ConnectionProtocol, PacketTrait, ProtocolPacket}; + +#[derive(Clone, Debug)] +pub enum StatusPacket { + ServerboundStatusRequestPacket( + serverbound_status_request_packet::ServerboundStatusRequestPacket, + ), + ClientboundStatusResponsePacket( + clientbound_status_response_packet::ClientboundStatusResponsePacket, + ), +} + +// #[async_trait] +// impl ProtocolPacket for StatusPacket { +impl StatusPacket { + fn get_inner(self) -> impl PacketTrait { + match self { + StatusPacket::ServerboundStatusRequestPacket(packet) => packet, + StatusPacket::ClientboundStatusResponsePacket(packet) => packet, + } + } + // fn get_inner(&self) -> StatusPacket { + // match self { + // StatusPacket::ServerboundStatusRequestPacket(packet) => packet, + // StatusPacket::ClientboundStatusResponsePacket(packet) => packet, + // } + // } + + fn id(&self) -> u32 { + match self { + StatusPacket::ServerboundStatusRequestPacket(_packet) => 0x00, + StatusPacket::ClientboundStatusResponsePacket(_packet) => 0x00, + } + } + + fn write(&self, buf: &mut Vec<u8>) { + match self { + StatusPacket::ServerboundStatusRequestPacket(packet) => packet.write(buf), + StatusPacket::ClientboundStatusResponsePacket(packet) => packet.write(buf), + } + } + + /// Read a packet by its id, ConnectionProtocol, and flow + async fn read< + T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send, + P: ProtocolPacket, + >( + id: u32, + flow: &PacketFlow, + buf: &mut BufReader<T>, + ) -> Result<P, String> + where + Self: Sized, + { + match flow { + PacketFlow::ServerToClient => match id { + 0x00 => Ok( + clientbound_status_response_packet::ClientboundStatusResponsePacket::read(buf) + .await?, + ), + _ => Err(format!("Unknown ServerToClient status packet id: {}", id)), + }, + PacketFlow::ClientToServer => match id { + 0x00 => Ok( + serverbound_status_request_packet::ServerboundStatusRequestPacket::read(buf) + .await?, + ), + _ => Err(format!("Unknown ClientToServer status packet id: {}", id)), + }, + } + } +} 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 56799677..066131cc 100644 --- a/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs +++ b/minecraft-protocol/src/packets/status/serverbound_status_request_packet.rs @@ -2,19 +2,21 @@ use async_trait::async_trait; use std::hash::Hash; use tokio::io::BufReader; -use crate::{ - packets::{Packet, PacketTrait}, -}; +use crate::packets::{Packet, PacketTrait, ProtocolPacket}; + +use super::StatusPacket; #[derive(Hash, Clone, Debug)] pub struct ServerboundStatusRequestPacket {} #[async_trait] impl PacketTrait for ServerboundStatusRequestPacket { - fn get(self) -> Packet { - Packet::ServerboundStatusRequestPacket(self) + fn get(self) -> StatusPacket { + StatusPacket::ServerboundStatusRequestPacket(self) + } + fn write(&self, _buf: &mut Vec<u8>) { + panic!("ServerboundStatusRequestPacket::write not implemented") } - fn write(&self, _buf: &mut Vec<u8>) {} async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>( _buf: &mut BufReader<T>, |