azalea

2 files changed, 85 insertions, 0 deletions

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)),
+            },
+        }
+    }
+}