update

Author: sergio-ivanuzzo

Cargo.toml

@@ -13,6 +13,7 @@ license-file = "LICENSE"
 [dependencies]
 anyhow = "1.0"
 arc4 = "0.1.0"
+async-broadcast = "0.7.1"
 async-trait = "0.1.77"
 bitflags = "2.4.2"
 byteorder = "1.4.3"
@@ -21,6 +22,7 @@ flate2 = "1.0.24"
 futures = "0.3.21"
 hmac-sha = "0.6.1"
 num-bigint = "0.4.3"
+num-traits = "0.2.18"
 rand = "0.9.0"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.114"
@@ -31,7 +33,6 @@ tentacli-packet = "7.0.0"
 tentacli-traits = "9.2.1"
 tentacli-utils = "2.1.0"
 tokio = { version = "1", features = ["sync", "net", "io-util", "macros", "time", "rt-multi-thread"] }
-num-traits = "0.2.18"
 
 [features]
 # use this feature to turn on println

src/lib.rs

@@ -0,0 +1,69 @@
+use std::sync::Arc;
+
+use anyhow::Result as AnyResult;
+use async_broadcast::Receiver as BroadcastReceiver;
+use futures::future::join_all;
+use tentacli_traits::types::HandlerOutput;
+use tokio::sync::Mutex;
+
+pub(crate) use primary::debug;
+
+pub use crate::primary::crypto::srp::Srp;
+use crate::primary::server::{LoginServer, WorldServer};
+pub use crate::primary::traits::base_server::{BaseServer, RunOptions};
+
+mod primary;
+
+#[derive(Default)]
+pub struct Options {
+    pub receiver: Option<BroadcastReceiver<HandlerOutput>>,
+    pub login_port: u16,
+    pub world_port: u16,
+}
+
+pub struct Server;
+impl Server {
+    pub async fn run(
+        Options {
+            receiver,
+            login_port,
+            world_port,
+        }: Options,
+    ) -> AnyResult<()> {
+        let srp = Arc::new(Mutex::new(Srp::new()));
+
+        let login_options = Arc::new(RunOptions {
+            srp: srp.clone(),
+            login_port,
+            world_port,
+            ..RunOptions::default()
+        });
+
+        let world_options = Arc::new(RunOptions {
+            srp,
+            receiver,
+            login_port,
+            world_port,
+        });
+
+        let run_login_server = || {
+            tokio::spawn(async move {
+                if let Err(err) = LoginServer::new().run(login_options).await {
+                    debug!("Error running Login Server: {}", err);
+                }
+            })
+        };
+
+        let run_world_server = || {
+            tokio::spawn(async move {
+                if let Err(err) = WorldServer::new().run(world_options).await {
+                    debug!("Error running World Server: {}", err);
+                }
+            })
+        };
+
+        join_all(vec![run_login_server(), run_world_server()]).await;
+
+        Ok(())
+    }
+}

src/main.rs

@@ -1,42 +1,15 @@
-use std::sync::Arc;
-
 use anyhow::Result as AnyResult;
-use futures::future::join_all;
-use tokio::sync::Mutex;
-
-pub(crate) use primary::debug;
-
-use crate::primary::crypto::srp::Srp;
-use crate::primary::server::{LoginServer, WorldServer};
-use crate::primary::traits::server::{RunOptions, Server};
 
-mod primary;
+use tine::{Options, Server};
 
 #[tokio::main]
 async fn main() -> AnyResult<()> {
-    let options = Arc::new(RunOptions {
-        srp: Arc::new(Mutex::new(Srp::new())),
-    });
-
-    let run_login_server = || {
-        let options = options.clone();
-        tokio::spawn(async move {
-            if let Err(err) = LoginServer::new().run(options).await {
-                debug!("Error running Login Server: {}", err);
-            }
-        })
-    };
-
-    let run_world_server = || {
-        let options = options.clone();
-        tokio::spawn(async move {
-            if let Err(err) = WorldServer::new().run(options).await {
-                debug!("Error running World Server: {}", err);
-            }
-        })
-    };
-
-    join_all(vec![run_login_server(), run_world_server()]).await;
+    Server::run(Options {
+        login_port: 3724,
+        world_port: 19999,
+        ..Options::default()
+    })
+    .await?;
 
     Ok(())
 }

src/primary/crypto/srp.rs

@@ -4,7 +4,7 @@ use sha1::Digest;
 
 const MODULUS: &str = "894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7";
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Srp {
     pub modulus: BigInt,
     pub generator: BigInt,

src/primary/server/auth/realmlist.rs

@@ -1,15 +1,12 @@
 use async_trait::async_trait;
-use rand::{random_range, Rng};
-use rand::distr::Alphanumeric;
+use rand::random_range;
 use serde::{Deserialize, Serialize};
 use tentacli_packet::{LoginPacket, Segment};
 use tentacli_traits::types::opcodes::Opcode;
 use tentacli_traits::types::realm::Realm;
 
-use crate::primary::server::WORLD_PORT;
 use crate::primary::traits::packet_handler::PacketHandler;
 use crate::primary::types::{HandlerInput, HandlerOutput, HandlerResult};
-use crate::primary::types::fields::realms::Realms;
 
 #[derive(LoginPacket, Serialize, Deserialize, Debug)]
 pub struct RealmlistIncoming {
@@ -28,18 +25,15 @@ struct Outgoing {
 pub struct Handler;
 #[async_trait]
 impl PacketHandler for Handler {
-    async fn handle(&mut self, _: &mut HandlerInput) -> HandlerResult {
-        let realms = Self::generate_unique_realms();
-        let realms_count = realms.len() as u16;
-
+    async fn handle(&mut self, input: &mut HandlerInput) -> HandlerResult {
         let realms_bytes = {
-            #[derive(Segment, Serialize, Deserialize)]
+            #[derive(Segment, Serialize)]
             struct RealmsSerializer {
-                realms: Realms,
+                realms: Vec<Realm>,
             }
 
             RealmsSerializer {
-                realms: Realms(realms.clone()),
+                realms: vec![Self::generate_realm(input.server_info.world_port)],
             }
             .to_binary()
             .unwrap()
@@ -49,7 +43,7 @@ impl PacketHandler for Handler {
             Outgoing {
                 size: (realms_bytes.len() + 8) as u16,
                 unknown: 0,
-                realms_count,
+                realms_count: 1,
                 realms: realms_bytes,
                 unknown2: 0x0010,
             }
@@ -59,40 +53,17 @@ impl PacketHandler for Handler {
 }
 
 impl Handler {
-    fn generate_realm() -> Realm {
+    fn generate_realm(port: u16) -> Realm {
         let mut realm = Realm::default();
 
-        let name: String = rand::rng()
-            .sample_iter(Alphanumeric)
-            .take(10)
-            .map(char::from)
-            .collect();
-
         realm.icon = 1;
         realm.lock = 0;
         realm.flags = 1;
-        realm.name = name;
-        realm.address = format!("127.0.0.1:{}", WORLD_PORT);
+        realm.name = String::from("TINE Aspect Server");
+        realm.address = format!("127.0.0.1:{}", port);
         realm.timezone = 1;
         realm.server_id = random_range(0..=100);
 
         realm
     }
-
-    fn generate_unique_realms() -> Vec<Realm> {
-        let random_count: usize = random_range(1..=10);
-
-        let mut realms = Vec::new();
-        let mut generated_names = std::collections::HashSet::new();
-
-        while realms.len() < random_count {
-            let realm = Self::generate_realm();
-
-            if generated_names.insert(realm.name.clone()) {
-                realms.push(realm);
-            }
-        }
-
-        realms
-    }
 }

src/primary/server/login_server.rs

@@ -7,23 +7,24 @@ use tokio::io::{AsyncReadExt, BufReader};
 use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 
-use crate::primary::server::{LOGIN_PORT, SERVER_HOST};
 use crate::primary::server::auth::{
     AuthProcessor, LoginChallengeIncoming, LoginProofIncoming, RealmlistIncoming,
 };
 use crate::primary::server::types::Packet;
+use crate::primary::traits::base_server::{BaseServer, Connection};
 use crate::primary::traits::processor::Processor;
-use crate::primary::traits::server::{Connection, Server};
 use crate::primary::types::ProcessorFunction;
+use crate::RunOptions;
 
 pub struct LoginServer {}
-
-#[async_trait]
-impl Server for LoginServer {
-    fn new() -> Self {
+impl LoginServer {
+    pub fn new() -> Self {
         Self {}
     }
+}
 
+#[async_trait]
+impl BaseServer for LoginServer {
     async fn read_packet(socket: &mut TcpStream, _: Arc<Mutex<Connection>>) -> AnyResult<Packet> {
         let opcode = socket.read_u8().await?;
         let mut reader = BufReader::new(socket);
@@ -45,15 +46,11 @@ impl Server for LoginServer {
         vec![Box::new(AuthProcessor::get_handlers)]
     }
 
-    fn host<'a>() -> &'a str {
-        SERVER_HOST
-    }
-
-    fn port() -> u16 {
-        LOGIN_PORT
-    }
-
     fn server_name<'a>() -> &'a str {
         "Login Server"
     }
+
+    fn port(options: Arc<RunOptions>) -> u16 {
+        options.login_port
+    }
 }

src/primary/server/mod.rs

@@ -12,10 +12,6 @@ mod realm;
 pub mod types;
 mod world_server;
 
-const SERVER_HOST: &str = "127.0.0.1";
-const LOGIN_PORT: u16 = 3724;
-const WORLD_PORT: u16 = 8999;
-
 #[allow(dead_code)]
 type SessionKey = Vec<u8>;
 #[allow(dead_code)]

src/primary/server/world_server.rs

@@ -8,25 +8,27 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio::sync::Mutex;
 
-use crate::primary::server::{SERVER_HOST, WORLD_PORT};
 use crate::primary::server::auth::auth_challenge;
 use crate::primary::server::player::PlayerProcessor;
 use crate::primary::server::realm::RealmProcessor;
 use crate::primary::server::types::Packet;
+use crate::primary::traits::base_server::{BaseServer, Connection, RunOptions};
 use crate::primary::traits::processor::Processor;
-use crate::primary::traits::server::{Connection, RunOptions, Server};
 use crate::primary::types::ProcessorFunction;
 
 const HEADER_SIZE: usize = 6;
 const OPCODE_SIZE: usize = 4;
 
 pub struct WorldServer {}
-#[async_trait]
-impl Server for WorldServer {
-    fn new() -> Self {
+
+impl WorldServer {
+    pub fn new() -> Self {
         Self {}
     }
+}
 
+#[async_trait]
+impl BaseServer for WorldServer {
     async fn read_packet(
         socket: &mut TcpStream,
         connection: Arc<Mutex<Connection>>,
@@ -64,15 +66,11 @@ impl Server for WorldServer {
         ]
     }
 
-    fn host<'a>() -> &'a str {
-        SERVER_HOST
-    }
-
-    fn port() -> u16 {
-        WORLD_PORT
-    }
-
     fn server_name<'a>() -> &'a str {
         "World Server"
     }
+
+    fn port(options: Arc<RunOptions>) -> u16 {
+        options.world_port
+    }
 }