json config replaced by toml config

- Added server and api addr setting
- Added auth_url for session request
- Added custom messages

Author: Andcool-Systems

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-tokio = { version = "1.0", features = ["full"] }
+tokio = { version = "1.43.0", features = ["full"] }
 actix-web = "4.9.0"
 bytes = "1.0"
 rsa = "0.9"
@@ -22,3 +22,4 @@ num-bigint = "0.4.6"
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 base64_light = "0.1.5"
+toml = "0.8.20"

config.json

@@ -0,0 +1,24 @@
+[api]
+addr = "0.0.0.0"
+port = 8008
+code_life_time = 300
+
+[server]
+addr = "0.0.0.0"
+port = 25566
+timeout = 10
+
+[server.config]
+protocol = 0
+version = "1.21"
+auth_url = "https://sessionserver.mojang.com/session/minecraft/hasJoined?username={{NAME}}&serverId={{HASH}}"
+
+[server.status]
+description = "§6mc-oauth.andcool.ru"
+players_max = 0
+players_online = 0
+icon_path = "server_icon.png"
+
+[messages]
+success = "Hello, §6{{NAME}}§r! Your code is: §a{{CODE}}"
+bad_session = "§cFailed to login: Invalid session (Try restarting your game and the launcher)"

config.toml

@@ -14,11 +14,17 @@ pub async fn load(path: &str) -> Result<()> {
         .await
         .expect("Couldn't load config file");
 
-    let mut config: types::Config =
-        serde_json::from_str(&file).expect("Couldn't parse config json");
-    match server_icon::load(&config.icon_path).await {
+    let mut config: types::Config  = match toml::from_str(&file) {
+        Ok(config) => config,
+        Err(err) => {
+            panic!("Couldn't parse config: {}", err.message())
+        }
+    };
+    
+    //let mut config: types::Config = toml::from_str(&file);
+    match server_icon::load(&config.server.status.icon_path).await {
         Ok(base64) => config.image = Some(format!("data:image/png;base64,{}", base64)),
-        Err(e) => warn!("Error loading server icon: {}", e)
+        Err(e) => warn!("Error loading server icon: {}", e),
     }
 
     CONFIG.set(config).expect("Couldn't load config");

src/config/mod.rs

@@ -1,35 +1,88 @@
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Deserialize, Debug)]
 pub struct Config {
-    /// Minecraft server port (Minecraft's default port is `25565`)
-    pub server_port: u16,
+    /// API config
+    pub api: API,
+
+    /// Minecraft server config
+    pub server: Server,
+
+    /// Messages config
+    pub messages: Messages,
+
+    #[serde(skip)]
+    /// Base 64 encoded server icon
+    pub image: Option<String>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct API {
+    /// API address
+    pub addr: String,
 
     /// API port
-    pub api_port: u16,
+    pub port: u16,
 
-    /// Display count of max server players
-    pub players_max: usize,
+    /// Life time of assigned code
+    pub code_life_time: u64,
+}
 
-    /// Display count of max server players
-    pub players_online: usize,
+#[derive(Deserialize, Debug)]
+pub struct Server {
+    /// Server address
+    pub addr: String,
 
-    /// Server protocol version (0 for auto)
-    pub proto_ver: usize,
+    /// Server port
+    pub port: u16,
 
-    /// Server version string (e.g. 1.20.5)
-    pub server_ver: String,
+    /// Server connection timeout
+    pub timeout: u64,
 
-    /// Server description (you can use a `§` codes)
-    pub motd: String,
+    /// Minecraft server config
+    pub config: ServerConfig,
 
-    /// Assigned 6-digit code life time in seconds
-    pub code_life_time: u64,
+    /// Server list ping config
+    pub status: ServerStatus,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ServerConfig {
+    /// Protocol version (`0` for auto)
+    pub protocol: usize,
+
+    /// Minecraft version string (e.g. `1.20.1`)
+    pub version: String,
+
+    /// Session Auth URL  
+    /// `{{NAME}}` in string will be replaced to client nickname  
+    /// `{{HASH}}` will be replaced to generated client hash
+    pub auth_url: String,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ServerStatus {
+    /// Server description (you can use MOTD)
+    pub description: String,
+
+    /// Max players count, displayed in server list
+    pub players_max: usize,
+
+    /// Online players count, displayed in server list
+    pub players_online: usize,
 
     /// Path to the server icon
     pub icon_path: String,
+}
 
-    #[serde(skip)]
-    /// Base 64 encoded server icon
-    pub image: Option<String>,
+#[derive(Deserialize, Debug)]
+pub struct Messages {
+    /// Message for success auth  
+    /// `{{NAME}}` will be replaced to client nickname  
+    /// `{{UUID}}` will be replaced to client UUID  
+    /// `{{CODE}}` will be replaced to generated code
+    pub success: String,
+
+    /// Message for Mojang API error
+    pub bad_session: String,
 }

src/config/types.rs

@@ -58,8 +58,9 @@ pub async fn handle(mut stream: TcpStream, keys: Arc<rsa::RsaPrivateKey>) -> Res
                                     disconnect::send(
                                         &mut stream,
                                         session,
-                                        "§cFailed to login: Invalid session (Try restarting your game and the launcher)".to_string()
-                                    ).await?;
+                                        config.messages.bad_session.clone(),
+                                    )
+                                    .await?;
                                     break;
                                 }
                                 let player_data = player_data.unwrap();
@@ -70,15 +71,20 @@ pub async fn handle(mut stream: TcpStream, keys: Arc<rsa::RsaPrivateKey>) -> Res
                                 map.insert(
                                     code.clone(),
                                     player_data.clone(),
-                                    Duration::from_secs(config.code_life_time),
+                                    Duration::from_secs(config.api.code_life_time),
                                 )
                                 .await;
 
                                 // Disconnect client with code
                                 disconnect::send(
                                     &mut stream,
                                     session,
-                                    format!("Hello, §6{}§r! Your code is: §a{}", player_data.name, code),
+                                    config
+                                        .messages
+                                        .success
+                                        .replace("{{NAME}}", &player_data.name)
+                                        .replace("{{UUID}}", &player_data.id)
+                                        .replace("{{CODE}}", &code),
                                 )
                                 .await?;
 

src/handlers/client_handler.rs

@@ -13,6 +13,7 @@ mod responses;
 
 use std::{
     net::{Ipv4Addr, SocketAddrV4},
+    str::FromStr,
     sync::Arc,
     time::Duration,
 };
@@ -43,7 +44,7 @@ async fn main() -> anyhow::Result<()> {
     init_logger(tracing::Level::INFO);
 
     // Load config from file
-    config::load("config.json").await?;
+    config::load("config.toml").await?;
     let config = config::get_config().await;
 
     // Generate key pair
@@ -52,19 +53,19 @@ async fn main() -> anyhow::Result<()> {
 
     // Start HTTP API
     let http = build_http_server(SocketAddrV4::new(
-        Ipv4Addr::new(0, 0, 0, 0),
-        config.api_port,
+        Ipv4Addr::from_str(&config.api.addr)?,
+        config.api.port,
     ));
     tokio::spawn(async move { http.await });
-    info!("API started on port {}", config.api_port);
+    info!("API started on port {}", config.api.port);
 
     // Bind TCP server
     let listener = TcpListener::bind(SocketAddrV4::new(
-        Ipv4Addr::new(0, 0, 0, 0),
-        config.server_port,
+        Ipv4Addr::from_str(&config.server.addr)?,
+        config.server.port,
     ))
     .await?;
-    info!("Server started on port {}", config.server_port);
+    info!("Server started on port {}", config.server.port);
 
     // Some graceful shutdown things
     let shutdown_signal = signal::ctrl_c();
@@ -97,7 +98,7 @@ async fn main() -> anyhow::Result<()> {
 
                         tokio::spawn(async move {
                             // Setting client timeout
-                            match timeout(Duration::from_secs(10), client_handler::handle(stream, keys)).await {
+                            match timeout(Duration::from_secs(config.server.timeout), client_handler::handle(stream, keys)).await {
                                 Ok(_) => info!("Connection from {} closed", addr),
                                 Err(e) => error!("Client exceptionally closed connection: {}", e)
                             }

src/main.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use anyhow::Result;
 use sha1::{Digest, Sha1};
 
-use crate::client_sessions::Session;
+use crate::{client_sessions::Session, config};
 use rsa::pkcs8::EncodePublicKey;
 
 use num_bigint::BigInt;
@@ -20,12 +20,16 @@ pub async fn join(
     digest.update(keys.to_public_key().to_public_key_der()?.as_bytes());
     let hash = BigInt::from_signed_bytes_be(&digest.finalize()).to_str_radix(16);
 
-    let url = format!(
-        "https://sessionserver.mojang.com/session/minecraft/hasJoined?username={}&serverId={}",
-        session.nickname.clone().unwrap(),
-        hash
-    );
-    let response = reqwest::get(url).await?;
+    let config = config::get_config().await;
+    let response = reqwest::get(
+        config
+            .server
+            .config
+            .auth_url
+            .replace("{{NAME}}", &session.nickname.clone().unwrap())
+            .replace("{{HASH}}", &hash),
+    )
+    .await?;
 
     if response.status().as_u16() != 200 {
         return Ok(None);

src/mojang/mod.rs

@@ -7,23 +7,23 @@ use crate::{client_sessions::Session, config::get_config, packets::status};
 
 pub async fn send(stream: &mut TcpStream, session: &mut Session) -> Result<()> {
     let config = get_config().await;
-    let proto_ver = if config.proto_ver == 0 {
+    let proto_ver = if config.server.config.protocol == 0 {
         session.proto_ver.unwrap()
     } else {
-        config.proto_ver
+        config.server.config.protocol
     };
 
     let data = status::StatusData {
         version: status::Version {
-            name: config.server_ver.clone(),
+            name: config.server.config.version.clone(),
             protocol: proto_ver,
         },
         players: status::Players {
-            max: config.players_max,
-            online: config.players_online,
+            max: config.server.status.players_max,
+            online: config.server.status.players_online,
             sample: vec![],
         },
-        description: json!({"text": config.motd.clone()}),
+        description: json!({"text": config.server.status.description.clone()}),
         favicon: config.image.clone(),
         enforces_secure_chat: false,
     };