azalea

11 files changed, 582 insertions, 0 deletions

diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs
new file mode 100644
index 00000000..a3ef2541
--- /dev/null
+++ b/azalea-protocol/src/packets/game/mod.rs
@@ -0,0 +1,35 @@
+use async_trait::async_trait;
+use tokio::io::BufReader;
+
+use crate::connect::PacketFlow;
+
+use super::ProtocolPacket;
+
+#[derive(Clone, Debug)]
+pub enum GamePacket
+where
+    Self: Sized, {}
+
+#[async_trait]
+impl ProtocolPacket for GamePacket {
+    fn id(&self) -> u32 {
+        0x00
+    }
+
+    fn write(&self, _buf: &mut Vec<u8>) {}
+
+    /// Read a packet by its id, ConnectionProtocol, and flow
+    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        _id: u32,
+        flow: &PacketFlow,
+        _buf: &mut BufReader<T>,
+    ) -> Result<GamePacket, String>
+    where
+        Self: Sized,
+    {
+        match flow {
+            PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
+            PacketFlow::ClientToServer => Err("HandshakePacket::read not implemented".to_string()),
+        }
+    }
+}
diff --git a/azalea-protocol/src/packets/handshake/client_intention_packet.rs b/azalea-protocol/src/packets/handshake/client_intention_packet.rs
new file mode 100644
index 00000000..868626b3
--- /dev/null
+++ b/azalea-protocol/src/packets/handshake/client_intention_packet.rs
@@ -0,0 +1,36 @@
+use std::hash::Hash;
+
+use tokio::io::BufReader;
+
+use crate::{mc_buf::Writable, packets::ConnectionProtocol};
+
+use super::HandshakePacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ClientIntentionPacket {
+    pub protocol_version: u32,
+    pub hostname: String,
+    pub port: u16,
+    /// 1 for status, 2 for login
+    pub intention: ConnectionProtocol,
+}
+
+impl ClientIntentionPacket {
+    pub fn get(self) -> HandshakePacket {
+        HandshakePacket::ClientIntentionPacket(self)
+    }
+
+    pub fn write(&self, buf: &mut Vec<u8>) {
+        buf.write_varint(self.protocol_version as i32).unwrap();
+        buf.write_utf(&self.hostname).unwrap();
+        buf.write_short(self.port).unwrap();
+        buf.write_varint(self.intention.clone() as i32).unwrap();
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        _buf: &mut BufReader<T>,
+    ) -> Result<HandshakePacket, String> {
+        Err("ClientIntentionPacket::parse not implemented".to_string())
+        // Ok(ClientIntentionPacket {}.get())
+    }
+}
diff --git a/azalea-protocol/src/packets/handshake/mod.rs b/azalea-protocol/src/packets/handshake/mod.rs
new file mode 100644
index 00000000..01010e1e
--- /dev/null
+++ b/azalea-protocol/src/packets/handshake/mod.rs
@@ -0,0 +1,49 @@
+pub mod client_intention_packet;
+
+use async_trait::async_trait;
+use tokio::io::BufReader;
+
+use crate::connect::PacketFlow;
+
+use super::ProtocolPacket;
+
+#[derive(Clone, Debug)]
+pub enum HandshakePacket
+where
+    Self: Sized,
+{
+    ClientIntentionPacket(client_intention_packet::ClientIntentionPacket),
+}
+
+#[async_trait]
+impl ProtocolPacket for HandshakePacket {
+    fn id(&self) -> u32 {
+        match self {
+            HandshakePacket::ClientIntentionPacket(_packet) => 0x00,
+        }
+    }
+
+    fn write(&self, buf: &mut Vec<u8>) {
+        match self {
+            HandshakePacket::ClientIntentionPacket(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>(
+        id: u32,
+        flow: &PacketFlow,
+        buf: &mut BufReader<T>,
+    ) -> Result<HandshakePacket, String>
+    where
+        Self: Sized,
+    {
+        match flow {
+            PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
+            PacketFlow::ClientToServer => match id {
+                0x00 => Ok(client_intention_packet::ClientIntentionPacket::read(buf).await?),
+                _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
+            },
+        }
+    }
+}
diff --git a/azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs b/azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs
new file mode 100644
index 00000000..093176eb
--- /dev/null
+++ b/azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs
@@ -0,0 +1,41 @@
+use std::hash::Hash;
+use tokio::io::BufReader;
+
+use crate::mc_buf::{self, Readable, Writable};
+
+use super::LoginPacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ClientboundCustomQueryPacket {
+    pub transaction_id: u32,
+    // TODO: this should be a resource location
+    pub identifier: String,
+    pub data: Vec<u8>,
+}
+
+impl ClientboundCustomQueryPacket {
+    pub fn get(self) -> LoginPacket {
+        LoginPacket::ClientboundCustomQueryPacket(self)
+    }
+
+    pub fn write(&self, buf: &mut Vec<u8>) {
+        buf.write_varint(self.transaction_id as i32).unwrap();
+        buf.write_utf(&self.identifier).unwrap();
+        buf.write_bytes(&self.data).unwrap();
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        buf: &mut BufReader<T>,
+    ) -> Result<LoginPacket, String> {
+        let transaction_id = buf.read_varint().await?.0 as u32;
+        // TODO: this should be a resource location
+        let identifier = buf.read_utf().await?;
+        let data = buf.read_bytes(1048576).await?;
+        Ok(ClientboundCustomQueryPacket {
+            transaction_id,
+            identifier,
+            data,
+        }
+        .get())
+    }
+}
diff --git a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
new file mode 100644
index 00000000..36a48706
--- /dev/null
+++ b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
@@ -0,0 +1,38 @@
+use std::hash::Hash;
+use tokio::io::BufReader;
+
+use crate::mc_buf::Readable;
+
+use super::LoginPacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ClientboundHelloPacket {
+    pub server_id: String,
+    pub public_key: Vec<u8>,
+    pub nonce: Vec<u8>,
+}
+
+impl ClientboundHelloPacket {
+    pub fn get(self) -> LoginPacket {
+        LoginPacket::ClientboundHelloPacket(self)
+    }
+
+    pub fn write(&self, _buf: &mut Vec<u8>) {
+        panic!("ClientboundHelloPacket::write not implemented")
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        buf: &mut BufReader<T>,
+    ) -> Result<LoginPacket, String> {
+        let server_id = buf.read_utf_with_len(20).await?;
+        let public_key = buf.read_byte_array().await?;
+        let nonce = buf.read_byte_array().await?;
+
+        Ok(ClientboundHelloPacket {
+            server_id,
+            public_key,
+            nonce,
+        }
+        .get())
+    }
+}
diff --git a/azalea-protocol/src/packets/login/mod.rs b/azalea-protocol/src/packets/login/mod.rs
new file mode 100644
index 00000000..f0ed6717
--- /dev/null
+++ b/azalea-protocol/src/packets/login/mod.rs
@@ -0,0 +1,63 @@
+pub mod clientbound_custom_query_packet;
+pub mod clientbound_hello_packet;
+pub mod serverbound_hello_packet;
+
+use async_trait::async_trait;
+use tokio::io::BufReader;
+
+use crate::connect::PacketFlow;
+
+use super::ProtocolPacket;
+
+#[derive(Clone, Debug)]
+pub enum LoginPacket
+where
+    Self: Sized,
+{
+    ClientboundCustomQueryPacket(clientbound_custom_query_packet::ClientboundCustomQueryPacket),
+    ServerboundHelloPacket(serverbound_hello_packet::ServerboundHelloPacket),
+    ClientboundHelloPacket(clientbound_hello_packet::ClientboundHelloPacket),
+}
+
+#[async_trait]
+impl ProtocolPacket for LoginPacket {
+    fn id(&self) -> u32 {
+        match self {
+            LoginPacket::ClientboundCustomQueryPacket(_packet) => 0x04,
+            LoginPacket::ServerboundHelloPacket(_packet) => 0x00,
+            LoginPacket::ClientboundHelloPacket(_packet) => 0x01,
+        }
+    }
+
+    fn write(&self, buf: &mut Vec<u8>) {
+        match self {
+            LoginPacket::ClientboundCustomQueryPacket(packet) => packet.write(buf),
+            LoginPacket::ServerboundHelloPacket(packet) => packet.write(buf),
+            LoginPacket::ClientboundHelloPacket(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>(
+        id: u32,
+        flow: &PacketFlow,
+        buf: &mut BufReader<T>,
+    ) -> Result<LoginPacket, String>
+    where
+        Self: Sized,
+    {
+        Ok(match flow {
+            PacketFlow::ServerToClient => match id {
+                0x01 => clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?,
+                0x04 => {
+                    clientbound_custom_query_packet::ClientboundCustomQueryPacket::read(buf).await?
+                }
+                _ => return Err(format!("Unknown ServerToClient status packet id: {}", id)),
+            },
+            PacketFlow::ClientToServer => match id {
+                0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
+                _ => return Err(format!("Unknown ClientToServer status packet id: {}", id)),
+            },
+        })
+    }
+}
diff --git a/azalea-protocol/src/packets/login/serverbound_hello_packet.rs b/azalea-protocol/src/packets/login/serverbound_hello_packet.rs
new file mode 100644
index 00000000..32a6dadc
--- /dev/null
+++ b/azalea-protocol/src/packets/login/serverbound_hello_packet.rs
@@ -0,0 +1,27 @@
+use std::hash::Hash;
+use tokio::io::BufReader;
+
+use crate::mc_buf::Writable;
+
+use super::LoginPacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ServerboundHelloPacket {
+    pub username: String,
+}
+
+impl ServerboundHelloPacket {
+    pub fn get(self) -> LoginPacket {
+        LoginPacket::ServerboundHelloPacket(self)
+    }
+
+    pub fn write(&self, buf: &mut Vec<u8>) {
+        buf.write_utf(&self.username).unwrap();
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        _buf: &mut BufReader<T>,
+    ) -> Result<LoginPacket, String> {
+        Err("ServerboundHelloPacket::read not implemented".to_string())
+    }
+}
diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs
new file mode 100644
index 00000000..a074b570
--- /dev/null
+++ b/azalea-protocol/src/packets/mod.rs
@@ -0,0 +1,146 @@
+pub mod game;
+pub mod handshake;
+pub mod login;
+pub mod status;
+
+use async_trait::async_trait;
+use tokio::io::BufReader;
+
+use crate::connect::PacketFlow;
+
+pub const PROTOCOL_VERSION: u32 = 757;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ConnectionProtocol {
+    Handshake = -1,
+    Game = 0,
+    Status = 1,
+    Login = 2,
+}
+
+#[derive(Clone, Debug)]
+pub enum Packet {
+    Game(game::GamePacket),
+    Handshake(handshake::HandshakePacket),
+    Login(login::LoginPacket),
+    Status(Box<status::StatusPacket>),
+}
+
+/// An enum of packets for a certain protocol
+#[async_trait]
+pub trait ProtocolPacket
+where
+    Self: Sized,
+{
+    fn id(&self) -> u32;
+
+    /// Read a packet by its id, ConnectionProtocol, and flow
+    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        id: u32,
+        flow: &PacketFlow,
+        buf: &mut BufReader<T>,
+    ) -> Result<Self, 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
+// where
+//     Self: Sized,
+// {
+//     /// Return a version of the packet that you can actually use for stuff
+//     fn get(self) -> dyn ProtocolPacket;
+
+//     fn write(&self, buf: &mut Vec<u8>);
+
+//     async fn read<T: AsyncRead + std::marker::Unpin + std::marker::Send, P: ProtocolPacket>(
+//         buf: &mut BufReader<T>,
+//     ) -> Result<P, String>
+//     where
+//         Self: Sized;
+// }
diff --git a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
new file mode 100644
index 00000000..1d8a3aa4
--- /dev/null
+++ b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
@@ -0,0 +1,58 @@
+use azalea_chat::component::Component;
+use serde::Deserialize;
+use serde_json::Value;
+use tokio::io::BufReader;
+
+use crate::mc_buf::Readable;
+
+use super::StatusPacket;
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct Version {
+    pub name: Component,
+    pub protocol: u32,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct SamplePlayer {
+    pub id: String,
+    pub name: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct Players {
+    pub max: u32,
+    pub online: u32,
+    pub sample: Vec<SamplePlayer>,
+}
+
+// the entire packet is just json, which is why it has deserialize
+#[derive(Clone, Debug, Deserialize)]
+pub struct ClientboundStatusResponsePacket {
+    pub description: Component,
+    pub favicon: Option<String>,
+    pub players: Players,
+    pub version: Version,
+}
+
+impl ClientboundStatusResponsePacket {
+    pub fn get(self) -> StatusPacket {
+        StatusPacket::ClientboundStatusResponsePacket(Box::new(self))
+    }
+
+    pub fn write(&self, _buf: &mut Vec<u8>) {}
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        buf: &mut BufReader<T>,
+    ) -> Result<StatusPacket, String> {
+        let status_string = buf.read_utf().await?;
+        let status_json: Value =
+            serde_json::from_str(status_string.as_str()).expect("Server status isn't valid JSON");
+
+        let packet = ClientboundStatusResponsePacket::deserialize(status_json)
+            .map_err(|e| e.to_string())?
+            .get();
+
+        Ok(packet)
+    }
+}
diff --git a/azalea-protocol/src/packets/status/mod.rs b/azalea-protocol/src/packets/status/mod.rs
new file mode 100644
index 00000000..ac6a34e1
--- /dev/null
+++ b/azalea-protocol/src/packets/status/mod.rs
@@ -0,0 +1,66 @@
+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::ProtocolPacket;
+
+#[derive(Clone, Debug)]
+pub enum StatusPacket
+where
+    Self: Sized,
+{
+    ServerboundStatusRequestPacket(
+        serverbound_status_request_packet::ServerboundStatusRequestPacket,
+    ),
+    ClientboundStatusResponsePacket(
+        Box<clientbound_status_response_packet::ClientboundStatusResponsePacket>,
+    ),
+}
+
+#[async_trait]
+impl ProtocolPacket for StatusPacket {
+    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>(
+        id: u32,
+        flow: &PacketFlow,
+        buf: &mut BufReader<T>,
+    ) -> Result<StatusPacket, 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/azalea-protocol/src/packets/status/serverbound_status_request_packet.rs b/azalea-protocol/src/packets/status/serverbound_status_request_packet.rs
new file mode 100644
index 00000000..6a58da1f
--- /dev/null
+++ b/azalea-protocol/src/packets/status/serverbound_status_request_packet.rs
@@ -0,0 +1,23 @@
+use std::hash::Hash;
+use tokio::io::BufReader;
+
+use super::StatusPacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ServerboundStatusRequestPacket {}
+
+impl ServerboundStatusRequestPacket {
+    pub fn get(self) -> StatusPacket {
+        StatusPacket::ServerboundStatusRequestPacket(self)
+    }
+
+    pub fn write(&self, _buf: &mut Vec<u8>) {
+        panic!("ServerboundStatusRequestPacket::write not implemented")
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        _buf: &mut BufReader<T>,
+    ) -> Result<StatusPacket, String> {
+        Err("ServerboundStatusRequestPacket::read not implemented".to_string())
+    }
+}