clean code

Author: Andcool-Systems

src/handlers/handshake.rs

@@ -14,14 +14,14 @@ impl MinecraftServer {
     pub async fn handle_handshake(&mut self) -> Result<()> {
         let handshake = HandshakePacket::parse(&mut self.buffer)?;
 
+        self.session.proto_ver = Some(handshake.proto_ver);
         self.session.next_state = match handshake.next_state {
             1 => NextStateEnum::Status,
             2 => NextStateEnum::Login,
             _ => NextStateEnum::Unknown,
         };
 
         // Check client's connecting hostname
-        self.session.proto_ver = Some(handshake.proto_ver);
         if let Some(server_ip) = &self.config.server.server_ip {
             if server_ip.ne(&handshake.server_addr) {
                 self.send_disconnect(self.config.messages.using_proxy.clone())

src/packets/status.rs

@@ -4,14 +4,20 @@ use bytes::BytesMut;
 use serde::Serialize;
 use serde_json::Value;
 
-pub struct StatusPacket {}
+pub struct StatusPacket {
+    data: StatusData,
+}
 
 impl StatusPacket {
-    pub fn build(data: StatusData) -> Result<BytesMut> {
+    pub fn new(data: StatusData) -> Self {
+        Self { data }
+    }
+
+    pub fn build(&self) -> Result<BytesMut> {
         let mut buffer = BytesMut::new();
 
         write_varint(&mut buffer, 0x00); // Packet id
-        write_utf8(&mut buffer, &serde_json::to_string(&data)?)?;
+        write_utf8(&mut buffer, &serde_json::to_string(&self.data)?)?;
 
         Ok(add_size(&buffer))
     }

src/responses/ping.rs

@@ -1,15 +1,13 @@
 use anyhow::Result;
 
 use crate::{packets::ping::PingPacket, server::MinecraftServer};
-use bytes::Buf;
 use tokio::io::AsyncWriteExt;
 
 impl MinecraftServer {
     /**
-    Handle ping and send response
+    Send ping response
     */
-    pub async fn handle_ping(&mut self) -> Result<()> {
-        let payload = self.buffer.get_i64();
+    pub async fn send_ping(&mut self, payload: i64) -> Result<()> {
         let packet = PingPacket { payload };
 
         self.stream.writable().await?;

src/responses/status.rs

@@ -1,6 +1,9 @@
+use crate::{
+    config::get_config,
+    packets::status::{self, StatusData, StatusPacket},
+    server::MinecraftServer,
+};
 use anyhow::Result;
-
-use crate::{config::get_config, packets::status, server::MinecraftServer};
 use serde_json::json;
 use tokio::io::AsyncWriteExt;
 
@@ -19,7 +22,7 @@ impl MinecraftServer {
             config.server.config.protocol
         };
 
-        let data = status::StatusData {
+        let packet = StatusPacket::new(StatusData {
             version: status::Version {
                 name: config.server.config.version.clone(),
                 protocol: proto_ver,
@@ -32,12 +35,10 @@ impl MinecraftServer {
             description: json!({"text": config.server.status.description.clone()}),
             favicon: config.image.clone(),
             enforces_secure_chat: false,
-        };
+        });
 
         self.stream.writable().await?;
-        self.stream
-            .write_all(&status::StatusPacket::build(data)?)
-            .await?;
+        self.stream.write_all(&packet.build()?).await?;
         Ok(())
     }
 }

src/server.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use aes::Aes128;
 use anyhow::{anyhow, Result};
-use bytes::{BufMut, BytesMut};
+use bytes::{Buf, BufMut, BytesMut};
 use cfb8::Encryptor;
 use std::{net::SocketAddr, sync::Arc, time::Duration};
 use tokio::net::TcpStream;
@@ -81,7 +81,7 @@ impl MinecraftServer {
         }
     }
 
-    pub async fn _run(&mut self) -> Result<()> {
+    async fn _run(&mut self) -> Result<()> {
         loop {
             self.stream.readable().await?;
             let mut temp_buf = vec![0; 1024];
@@ -144,7 +144,8 @@ impl MinecraftServer {
         match self.session.next_state {
             NextStateEnum::Status => {
                 // Handle ping request
-                self.handle_ping().await?
+                let payload = self.buffer.get_i64();
+                self.send_ping(payload).await?
             }
             NextStateEnum::Login => {
                 debug!("Received encryption response");
@@ -159,15 +160,14 @@ impl MinecraftServer {
     async fn auth_client(&mut self) -> Result<()> {
         let player_data = mojang::join(&mut self.session, self.keys.clone()).await?;
 
-        if player_data.is_none() {
-            debug!("Mojang API error");
-            self.send_disconnect(self.config.messages.bad_session.clone())
-                .await?;
-            return Err(anyhow!("Mojang API error"));
-        }
-
-        // HA-HA: Unwrap is safe, because we already checked for none above
-        let player_data = player_data.unwrap();
+        let player_data = match player_data {
+            Some(x) => x,
+            None => {
+                self.send_disconnect(self.config.messages.bad_session.clone())
+                    .await?;
+                return Err(anyhow!("Mojang API error"));
+            }
+        };
         let map = get_map().await;
         let code = generate_code(6); // Generate 6-digit code