update

Author: sergio-ivanuzzo

Cargo.toml

@@ -1,20 +1,20 @@
 [package]
 name = "tine"
-version = "0.1.0"
+version = "1.0.0"
 edition = "2021"
 authors = ["Sergio Ivanuzzo <sergio.ivanuzzo@gmail.com>"]
 description = "TINE IS NOT EMULATOR, it is just a tiny wow server for v3.3.5a (currently only this version)"
 readme = "README.md"
 keywords = ["idewave", "wow-server"]
 license-file = "LICENSE"
 repository = "https://github.com/idewave/tine"
+publish = false
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [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"
@@ -33,7 +33,7 @@ tentacli-formatters = "0.1.0"
 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"] }
+tokio = { version = "1", features = ["sync", "net", "io-util", "macros", "time", "rt-multi-thread", "signal"] }
 
 [features]
 # use this feature to turn on println

src/lib.rs

@@ -1,13 +1,14 @@
 use anyhow::Result as AnyResult;
 
-use tine::{Options, Server};
+use crate::primary::{Options, Server};
+
+mod primary;
 
 #[tokio::main]
 async fn main() -> AnyResult<()> {
     Server::run(Options {
         login_port: 3724,
         world_port: 19999,
-        ..Options::default()
     })
     .await?;
 

src/main.rs

@@ -1,4 +1,3 @@
-use std::fmt::{Debug, Formatter};
 use hmacsha::HmacSha;
 use sha1::Sha1;
 
@@ -12,41 +11,48 @@ const DECRYPTION_KEY: [u8; 16] = [
     0xC2, 0xB3, 0x72, 0x3C, 0xC6, 0xAE, 0xD9, 0xB5, 0x34, 0x3C, 0x53, 0xEE, 0x2F, 0x43, 0x67, 0xCE
 ];
 
-pub struct HeaderCrypt {
-    encryptor: RC4,
-    decryptor: RC4,
+#[derive(Debug)]
+pub struct HeaderEncryptor {
+    _instance: RC4,
 }
 
-impl HeaderCrypt {
+impl HeaderEncryptor {
     pub fn new(secret: &[u8]) -> Self {
         let mut encryptor = RC4::new(
             HmacSha::new(&ENCRYPTION_KEY, secret, Sha1::default()).compute_digest().to_vec()
         );
 
-        let mut decryptor = RC4::new(
-            HmacSha::new(&DECRYPTION_KEY, secret, Sha1::default()).compute_digest().to_vec()
-        );
-
         let _ = &encryptor.encrypt(&vec![0; 1024]);
-        let _ = &decryptor.encrypt(&vec![0; 1024]);
 
         Self {
-            encryptor,
-            decryptor,
+            _instance: encryptor,
         }
     }
 
     pub fn encrypt(&mut self, data: &[u8]) -> Vec<u8> {
-        self.encryptor.encrypt(data)
+        self._instance.encrypt(data)
     }
+}
 
-    pub fn decrypt(&mut self, data: &[u8]) -> Vec<u8> {
-        self.decryptor.encrypt(data)
-    }
+#[derive(Debug)]
+pub struct HeaderDecryptor {
+    _instance: RC4,
 }
 
-impl Debug for HeaderCrypt {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "AuthCrypt")
+impl HeaderDecryptor {
+    pub fn new(secret: &[u8]) -> Self {
+        let mut decryptor = RC4::new(
+            HmacSha::new(&DECRYPTION_KEY, secret, Sha1::default()).compute_digest().to_vec()
+        );
+
+        let _ = &decryptor.encrypt(&vec![0; 1024]);
+
+        Self {
+            _instance: decryptor,
+        }
+    }
+
+    pub fn decrypt(&mut self, data: &[u8]) -> Vec<u8> {
+        self._instance.encrypt(data)
     }
 }

src/primary/crypto/header_crypt.rs

@@ -1,3 +1,12 @@
+use std::sync::Arc;
+
+use futures::future::join_all;
+use tokio::sync::Mutex;
+
+use crate::primary::crypto::srp::Srp;
+use crate::primary::server::{LoginServer, WorldServer};
+use crate::primary::traits::server::{BaseServer, RunOptions};
+
 pub mod crypto;
 pub mod server;
 pub mod traits;
@@ -11,3 +20,45 @@ macro_rules! debug {
 }
 
 pub(crate) use debug;
+
+#[derive(Default)]
+pub struct Options {
+    pub login_port: u16,
+    pub world_port: u16,
+}
+
+pub struct Server;
+impl Server {
+    pub async fn run(
+        Options {
+            login_port,
+            world_port,
+        }: Options,
+    ) -> anyhow::Result<()> {
+        let srp = Arc::new(Mutex::new(Srp::new()));
+
+        let run_login_server = |port: u16| {
+            let options = RunOptions { srp: srp.clone(), port, world_port };
+
+            tokio::spawn(async move {
+                if let Err(err) = LoginServer::default().start(options).await {
+                    debug!("Error running Login Server: {}", err);
+                }
+            })
+        };
+
+        let run_world_server = |port: u16| {
+            let options = RunOptions { srp: srp.clone(), port, world_port };
+
+            tokio::spawn(async move {
+                if let Err(err) = WorldServer::default().start(options).await {
+                    debug!("Error running World Server: {}", err);
+                }
+            })
+        };
+
+        join_all(vec![run_login_server(login_port), run_world_server(world_port)]).await;
+
+        Ok(())
+    }
+}

src/primary/mod.rs

@@ -33,7 +33,7 @@ impl PacketHandler for Handler {
             }
 
             RealmsSerializer {
-                realms: vec![Self::generate_realm(input.server_info.world_port)],
+                realms: vec![Self::generate_realm(input.world_port)],
             }
             .to_binary()
             .unwrap()

src/primary/server/auth/realmlist.rs

@@ -1,47 +1,49 @@
 use std::sync::Arc;
 
-use anyhow::Result as AnyResult;
 use async_trait::async_trait;
 use tentacli_traits::types::opcodes::Opcode;
 use tokio::io::{AsyncReadExt, BufReader};
 use tokio::net::tcp::OwnedReadHalf;
+use tokio::sync::mpsc::Sender;
 use tokio::sync::Mutex;
+use tokio::task::JoinHandle;
 
+use crate::primary::crypto::header_crypt::HeaderDecryptor;
 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::BaseServer;
 use crate::primary::types::ProcessorFunction;
-use crate::RunOptions;
 
-pub struct LoginServer {}
-impl LoginServer {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
+#[derive(Default)]
+pub struct LoginServer;
 
 #[async_trait]
 impl BaseServer for LoginServer {
-    async fn read_packet(
-        socket: &mut OwnedReadHalf,
-        _: Arc<Mutex<Connection>>,
-    ) -> AnyResult<Packet> {
-        let opcode = socket.read_u8().await?;
-        let mut reader = BufReader::new(socket);
-
-        let data = match opcode {
-            Opcode::LOGIN_CHALLENGE => LoginChallengeIncoming::from_stream(&mut reader).await?,
-            Opcode::LOGIN_PROOF => LoginProofIncoming::from_stream(&mut reader).await?,
-            Opcode::REALM_LIST => RealmlistIncoming::from_stream(&mut reader).await?,
-            _ => vec![],
-        };
-
-        Ok(Packet {
-            opcode: opcode as u32,
-            data,
+    fn handle_read(
+        input_sender: Sender<Packet>,
+        mut reader: BufReader<OwnedReadHalf>,
+        _: Arc<Mutex<Option<HeaderDecryptor>>>,
+    ) -> JoinHandle<anyhow::Result<()>> {
+        tokio::spawn(async move {
+            loop {
+                let opcode = reader.read_u8().await?;
+
+                let body = match opcode {
+                    Opcode::LOGIN_CHALLENGE => {
+                        LoginChallengeIncoming::from_stream(&mut reader).await?
+                    }
+                    Opcode::LOGIN_PROOF => LoginProofIncoming::from_stream(&mut reader).await?,
+                    Opcode::REALM_LIST => RealmlistIncoming::from_stream(&mut reader).await?,
+                    _ => vec![],
+                };
+
+                if !body.is_empty() {
+                    input_sender.send(Packet { opcode: opcode as u32, body }).await?;
+                }
+            }
         })
     }
 
@@ -52,8 +54,4 @@ impl BaseServer for LoginServer {
     fn server_name<'a>() -> &'a str {
         "Login Server"
     }
-
-    fn port(options: Arc<RunOptions>) -> u16 {
-        options.login_port
-    }
 }

src/primary/server/login_server.rs

@@ -1,22 +1,23 @@
 use async_trait::async_trait;
 
-use crate::primary::crypto::header_crypt::HeaderCrypt;
+use crate::primary::crypto::header_crypt::{HeaderDecryptor, HeaderEncryptor};
 use crate::primary::traits::packet_handler::PacketHandler;
-use crate::primary::types::{HandlerInput, HandlerResult};
+use crate::primary::types::{HandlerInput, HandlerOutput, HandlerResult};
 
 pub struct Handler;
 #[async_trait]
 impl PacketHandler for Handler {
     async fn handle(&mut self, input: &mut HandlerInput) -> HandlerResult {
-        let response = Vec::new();
         let session_key = {
             let guard = input.srp.lock().await;
             guard.session_key.as_ref().unwrap().clone()
         };
 
-        let mut guard = input.connection.lock().await;
-        guard.header_crypt = Some(HeaderCrypt::new(&session_key));
-
-        Ok(response)
+        Ok(vec![
+            HandlerOutput::HeaderCrypt(
+                HeaderEncryptor::new(&session_key),
+                HeaderDecryptor::new(&session_key),
+            )
+        ])
     }
 }

src/primary/server/realm/set_encryption.rs

@@ -1,4 +1,4 @@
 pub struct Packet {
     pub opcode: u32,
-    pub data: Vec<u8>,
-}
+    pub body: Vec<u8>,
+}