Implement Query protocol

README.md

@@ -63,7 +63,7 @@ and customizable experience. It prioritizes performance and player enjoyment whi
   - [x] Player Combat
 - Server
   - [ ] Plugins
-  - [ ] Query
+  - [x] Query
   - [x] RCON
   - [x] Inventories
   - [x] Particles

pumpkin-config/src/lib.rs

@@ -1,6 +1,7 @@
 use log::warn;
 use logging::LoggingConfig;
 use pumpkin_core::{Difficulty, GameMode};
+use query::QueryConfig;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 // TODO: when https://github.com/rust-lang/rfcs/pull/3681 gets merged, replace serde-inline-default with native syntax
@@ -16,6 +17,7 @@ use std::{
 pub mod auth;
 pub mod logging;
 pub mod proxy;
+pub mod query;
 pub mod resource_pack;
 
 pub use auth::AuthenticationConfig;
@@ -53,6 +55,7 @@ pub struct AdvancedConfiguration {
     pub rcon: RCONConfig,
     pub pvp: PVPConfig,
     pub logging: LoggingConfig,
+    pub query: QueryConfig,
 }
 
 #[serde_inline_default]

pumpkin-config/src/query.rs

@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+use serde_inline_default::serde_inline_default;
+
+#[serde_inline_default]
+#[derive(Deserialize, Serialize, Default)]
+pub struct QueryConfig {
+    #[serde_inline_default(false)]
+    pub enabled: bool,
+    // Optional so if not specified the port server is running on will be used
+    #[serde_inline_default(None)]
+    pub port: Option<u16>,
+}

pumpkin-protocol/Cargo.toml

@@ -14,7 +14,7 @@ serde.workspace = true
 thiserror.workspace = true
 itertools.workspace = true
 log.workspace = true
-
+tokio.workspace = true
 num-traits.workspace = true
 num-derive.workspace = true
 

pumpkin-protocol/src/lib.rs

@@ -6,6 +6,7 @@ pub mod bytebuf;
 pub mod client;
 pub mod packet_decoder;
 pub mod packet_encoder;
+pub mod query;
 pub mod server;
 pub mod slot;
 

pumpkin-protocol/src/query.rs

@@ -0,0 +1,213 @@
+use std::ffi::CString;
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+pub struct SBasePacket {
+    pub magic: u16,
+    pub session_id: i32,
+    pub payload: SBasePayload,
+}
+
+pub enum SBasePayload {
+    Handshake,
+    BasicInfo(i32),
+    FullInfo(i32),
+}
+
+impl SBasePacket {
+    // We don't care what error it is as any packet with errors will be ingnored
+    pub async fn decode(mut reader: impl AsyncReadExt + Unpin) -> Result<Self, ()> {
+        let magic = reader.read_u16().await.map_err(|_| ())?;
+        let packet_type = reader.read_u8().await.map_err(|_| ())?;
+        let session_id = reader.read_i32().await.map_err(|_| ())?;
+
+        match packet_type {
+            // Status
+            0 => {
+                let challange_token = reader.read_i32().await.map_err(|_| ())?;
+                let mut buf = [0; 4];
+
+                // If payload is padded to 8 bytes, the client is requesting full status response
+                // In other terms, check if there are 4 extra bytes at the end
+                // The extra bytes should be meaningless
+                // Otherwise the client is requesting basic status response
+                match reader.read(&mut buf).await {
+                    Ok(0) => Ok(Self {
+                        magic,
+                        session_id,
+                        payload: SBasePayload::BasicInfo(challange_token),
+                    }),
+                    Ok(4) => Ok(Self {
+                        magic,
+                        session_id,
+                        payload: SBasePayload::FullInfo(challange_token),
+                    }),
+                    _ => {
+                        // Just ingnore malformed packets or errors
+                        Err(())
+                    }
+                }
+            }
+
+            // Handshake
+            9 => Ok(Self {
+                magic,
+                session_id,
+                payload: SBasePayload::Handshake,
+            }),
+
+            _ => Err(()),
+        }
+    }
+}
+
+pub struct CBasePacket {
+    pub session_id: i32,
+    pub payload: CBasePayload,
+}
+
+#[derive(Debug)]
+pub enum CBasePayload {
+    Handshake {
+        // For simplicity use a number type
+        // Should be encoded as string here
+        // Will be converted in encoding
+        challange_token: i32,
+    },
+    BasicInfo {
+        // Use CString as protocol requires nul terminated strings
+        motd: CString,
+        // Game type is hardcoded
+        map: CString,
+        num_players: usize,
+        max_players: usize,
+        host_port: u16,
+        host_ip: CString,
+    },
+    FullInfo {
+        hostname: CString,
+        // Game type and game id are hardcoded into protocol
+        // They are not here as they cannot be changed
+        version: CString,
+        plugins: CString,
+        map: CString,
+        num_players: usize,
+        max_players: usize,
+        host_port: u16,
+        host_ip: CString,
+        players: Vec<CString>,
+    },
+}
+
+impl CBasePacket {
+    pub async fn encode(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+
+        match &self.payload {
+            CBasePayload::Handshake { challange_token } => {
+                // Packet Type
+                buf.write_u8(9).await.unwrap();
+                // Session ID
+                buf.write_i32(self.session_id).await.unwrap();
+                // Challange token
+                // Use CString to add null terminator and ensure no null bytes in the middle of data
+                // Unwrap here since there should be no errors with nulls in the middle of data
+                let token = CString::new(challange_token.to_string()).unwrap();
+                buf.extend_from_slice(token.as_bytes_with_nul());
+            }
+            CBasePayload::BasicInfo {
+                motd,
+                map,
+                num_players,
+                max_players,
+                host_port,
+                host_ip,
+            } => {
+                // Packet Type
+                buf.write_u8(0).await.unwrap();
+                // Session ID
+                buf.write_i32(self.session_id).await.unwrap();
+                // MOTD
+                buf.extend_from_slice(motd.as_bytes_with_nul());
+                // Game Type
+                let game_type = CString::new("SMP").unwrap();
+                buf.extend_from_slice(game_type.as_bytes_with_nul());
+                // Map
+                buf.extend_from_slice(map.as_bytes_with_nul());
+                // Num players
+                let num_players = CString::new(num_players.to_string()).unwrap();
+                buf.extend_from_slice(num_players.as_bytes_with_nul());
+                // Max players
+                let max_players = CString::new(max_players.to_string()).unwrap();
+                buf.extend_from_slice(max_players.as_bytes_with_nul());
+                // Port
+                // No idea why the port needs to be in little endian
+                buf.write_u16_le(*host_port).await.unwrap();
+                // IP
+                buf.extend_from_slice(host_ip.as_bytes_with_nul());
+            }
+            CBasePayload::FullInfo {
+                hostname,
+                version,
+                plugins,
+                map,
+                num_players,
+                max_players,
+                host_port,
+                host_ip,
+                players,
+            } => {
+                // Packet type
+                buf.write_u8(0).await.unwrap();
+                // Session ID
+                buf.write_i32(self.session_id).await.unwrap();
+
+                // Padding (11 bytes, meaningless)
+                // This is the padding used by vanilla
+                const PADDING_START: [u8; 11] = [
+                    0x73, 0x70, 0x6C, 0x69, 0x74, 0x6E, 0x75, 0x6D, 0x00, 0x80, 0x00,
+                ];
+                buf.extend_from_slice(PADDING_START.as_slice());
+
+                // Key-value pairs
+                // Keys will not error when encoding as CString
+                for (key, value) in [
+                    ("hostname", hostname),
+                    ("gametype", &CString::new("SMP").unwrap()),
+                    ("game_id", &CString::new("MINECRAFT").unwrap()),
+                    ("version", version),
+                    ("plugins", plugins),
+                    ("map", map),
+                    (
+                        "numplayers",
+                        &CString::new(num_players.to_string()).unwrap(),
+                    ),
+                    (
+                        "maxplayers",
+                        &CString::new(max_players.to_string()).unwrap(),
+                    ),
+                    ("hostport", &CString::new(host_port.to_string()).unwrap()),
+                    ("hostip", host_ip),
+                ] {
+                    buf.extend_from_slice(CString::new(key).unwrap().as_bytes_with_nul());
+                    buf.extend_from_slice(value.as_bytes_with_nul());
+                }
+
+                // Padding (10 bytes, meaningless), with one extra 0x00 for the extra required null terminator after the Key Value section
+                const PADDING_END: [u8; 11] = [
+                    0x00, 0x01, 0x70, 0x6C, 0x61, 0x79, 0x65, 0x72, 0x5F, 0x00, 0x00,
+                ];
+                buf.extend_from_slice(PADDING_END.as_slice());
+
+                // Players
+                for player in players {
+                    buf.extend_from_slice(player.as_bytes_with_nul());
+                }
+                // Required extra null terminator
+                buf.write_u8(0).await.unwrap();
+            }
+        }
+
+        buf
+    }
+}

pumpkin/src/main.rs

@@ -44,6 +44,7 @@ pub mod command;
 pub mod entity;
 pub mod error;
 pub mod proxy;
+pub mod query;
 pub mod rcon;
 pub mod server;
 pub mod world;
@@ -117,10 +118,13 @@ async fn main() -> io::Result<()> {
     let time = Instant::now();
 
     // Setup the TCP server socket.
-    let addr = BASIC_CONFIG.server_address;
-    let listener = tokio::net::TcpListener::bind(addr)
+    let listener = tokio::net::TcpListener::bind(BASIC_CONFIG.server_address)
         .await
         .expect("Failed to start TcpListener");
+    // In the event the user puts 0 for their port, this will allow us to know what port it is running on
+    let addr = listener
+        .local_addr()
+        .expect("Unable to get the address of server!");
 
     let use_console = ADVANCED_CONFIG.commands.use_console;
     let rcon = ADVANCED_CONFIG.rcon.clone();
@@ -140,6 +144,12 @@ async fn main() -> io::Result<()> {
             RCONServer::new(&rcon, server).await.unwrap();
         });
     }
+
+    if ADVANCED_CONFIG.query.enabled {
+        log::info!("Query protocol enabled. Starting...");
+        tokio::spawn(query::start_query_handler(server.clone(), addr));
+    }
+
     {
         let server = server.clone();
         tokio::spawn(async move {