Merge branch 'master' into rework/better-chunk-sending

Author: ReCore-sys

.etc/example-config.toml

@@ -10,6 +10,8 @@ max_players = 100
 network_tick_rate = 30
 # World name to load
 world = "world"
+# Whether the server should validate players via the whitelist
+whitelist = false
 # Network compression threshold (can be negative). This decides how long a packet has to be before it is compressed.
 # Very small packets may actually increase in size when compressed, so setting it to 0 won't be perfect in all situations.
 # Set to -1 to disable compression.

Cargo.toml

@@ -123,6 +123,7 @@ parking_lot = "0.12.3"
 rayon = "1.10.0"
 
 # Network
+reqwest = { version = "0.12.9", features = ["json"] }
 
 # Error handling
 thiserror = "2.0.3"
@@ -139,6 +140,7 @@ serde_derive = "1.0.210"
 base64 = "0.22.1"
 bitcode = "0.6.3"
 bitcode_derive = "0.6.3"
+toml = "0.8.19"
 
 # Bit manipulation
 byteorder = "1.5.0"
@@ -184,6 +186,7 @@ colored = "2.1.0"
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
+regex = "1.11.1"
 
 # I/O
 tempfile = "3.12.0"

src/bin/src/main.rs

@@ -5,6 +5,7 @@ extern crate core;
 use crate::errors::BinaryError;
 use clap::Parser;
 use ferrumc_config::statics::get_global_config;
+use ferrumc_config::whitelist::create_whitelist;
 use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_ecs::Universe;
 use ferrumc_general_purpose::paths::get_root_path;
@@ -75,10 +76,11 @@ async fn main() {
 async fn entry() -> Result<()> {
     let state = create_state().await?;
     let global_state = Arc::new(state);
+    create_whitelist().await;
 
     let all_system_handles = tokio::spawn(definition::start_all_systems(global_state.clone()));
 
-    // Start the systems and wait until all of them are done
+    //Start the systems and wait until all of them are done
     all_system_handles.await??;
 
     // Stop all systems

src/bin/src/packet_handlers/login_process.rs

@@ -1,3 +1,4 @@
+use ferrumc_config::statics::{get_global_config, get_whitelist};
 use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_core::identity::player_identity::PlayerIdentity;
 use ferrumc_core::transform::grounded::OnGround;
@@ -16,6 +17,7 @@ use ferrumc_net::packets::outgoing::client_bound_known_packs::ClientBoundKnownPa
 use ferrumc_net::packets::outgoing::finish_configuration::FinishConfigurationPacket;
 use ferrumc_net::packets::outgoing::game_event::GameEventPacket;
 use ferrumc_net::packets::outgoing::keep_alive::OutgoingKeepAlivePacket;
+use ferrumc_net::packets::outgoing::login_disconnect::LoginDisconnectPacket;
 use ferrumc_net::packets::outgoing::login_play::LoginPlayPacket;
 use ferrumc_net::packets::outgoing::login_success::LoginSuccessPacket;
 use ferrumc_net::packets::outgoing::registry_data::get_registry_packets;
@@ -32,11 +34,10 @@ async fn handle_login_start(
     login_start_event: LoginStartEvent,
     state: GlobalState,
 ) -> Result<LoginStartEvent, NetError> {
-    debug!("Handling login start event");
-
     let uuid = login_start_event.login_start_packet.uuid;
     let username = login_start_event.login_start_packet.username.as_str();
-    debug!("Received login start from user with username {}", username);
+    let player_identity = PlayerIdentity::new(username.to_string(), uuid);
+    debug!("Handling login start event for user: {username}, uuid: {uuid}");
 
     // Add the player identity component to the ECS for the entity.
     state
@@ -52,6 +53,28 @@ async fn handle_login_start(
         .universe
         .get_mut::<StreamWriter>(login_start_event.conn_id)?;
 
+    if get_global_config().whitelist {
+        let whitelist = get_whitelist();
+
+        if whitelist.get(&uuid).is_none() {
+            writer
+                .send_packet(
+                    &LoginDisconnectPacket::new(
+                        "{\"translate\":\"multiplayer.disconnect.not_whitelisted\"}",
+                    ),
+                    &NetEncodeOpts::WithLength,
+                )
+                .await?;
+            return Ok(login_start_event);
+        }
+    }
+
+    // Add the player identity component to the ECS for the entity.
+    state
+        .universe
+        .add_component::<PlayerIdentity>(login_start_event.conn_id, player_identity)?;
+
+    //Send a Login Success Response to further the login sequence
     writer
         .send_packet(
             &LoginSuccessPacket::new(uuid, username),

src/lib/net/src/packets/outgoing/login_disconnect.rs

@@ -0,0 +1,14 @@
+use ferrumc_macros::{packet, NetEncode};
+use std::io::Write;
+
+#[derive(NetEncode)]
+#[packet(packet_id = 0x00)]
+pub struct LoginDisconnectPacket<'a> {
+    pub reason: &'a str,
+}
+
+impl<'a> LoginDisconnectPacket<'a> {
+    pub fn new(reason: &'a str) -> Self {
+        Self { reason }
+    }
+}

src/lib/net/src/packets/outgoing/mod.rs

@@ -6,6 +6,7 @@ pub mod disconnect;
 pub mod finish_configuration;
 pub mod game_event;
 pub mod keep_alive;
+pub mod login_disconnect;
 pub mod login_play;
 pub mod login_success;
 pub mod ping_response;

src/lib/utils/config/Cargo.toml

@@ -5,12 +5,18 @@ edition = "2021"
 description = "FerrumC configuration utilities"
 
 [dependencies]
-toml = "0.8.19"
+toml = { workspace = true }
 thiserror = { workspace = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 tracing = { workspace = true }
 parking_lot = { workspace = true }
 base64 = { workspace = true }
 ferrumc-general-purpose = { workspace = true }
-lazy_static = { workspace = true }
+ferrumc-core = { workspace = true }
+lazy_static = { workspace = true }
+dashmap = { workspace = true }
+uuid = { workspace = true }
+regex = { workspace = true }
+reqwest = { workspace = true }
+futures = { workspace = true }

src/lib/utils/config/src/lib.rs

@@ -15,6 +15,7 @@ pub mod favicon;
 pub mod server_config;
 pub mod setup;
 pub mod statics;
+pub mod whitelist;
 
 // Re-exports
 pub use server_config::DatabaseConfig;

src/lib/utils/config/src/server_config.rs

@@ -15,6 +15,7 @@ use serde_derive::{Deserialize, Serialize};
 /// - `database` - [DatabaseConfig]: The configuration for the database.
 /// - `world`: The name of the world that the server will load.
 /// - `network_compression_threshold`: The threshold at which the server will compress network packets.
+/// - `whitelist`: Whether the server whitelist is enabled or not.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct ServerConfig {
     pub host: String,
@@ -25,6 +26,7 @@ pub struct ServerConfig {
     pub database: DatabaseConfig,
     pub world: String,
     pub network_compression_threshold: i32, // Can be negative
+    pub whitelist: bool,
 }
 
 /// The database configuration section from [ServerConfig].

src/lib/utils/config/src/setup.rs

@@ -1,4 +1,5 @@
 use crate::statics::DEFAULT_CONFIG;
+use crate::whitelist::create_blank_whitelist_file;
 use ferrumc_general_purpose::paths::get_root_path;
 use std::fs::File;
 use std::io::Write;
@@ -26,6 +27,9 @@ impl From<std::io::Error> for SetupError {
 }
 
 pub fn setup() -> Result<(), SetupError> {
+    if !std::fs::exists(get_root_path().join("whitelist.txt"))? {
+        create_blank_whitelist_file();
+    }
     if std::fs::exists(get_root_path().join("config.toml"))? {
         return Ok(());
     }