- add: join server handler

- add: validate session function to validate the session status

packet-service/src/auth_client.rs

@@ -1,5 +1,5 @@
 use crate::auth::auth_service_client::AuthServiceClient;
-use crate::auth::{Empty, LoginRequest, LoginResponse, LogoutRequest, ValidateTokenRequest, ValidateTokenResponse};
+use crate::auth::{Empty, LoginRequest, LoginResponse, LogoutRequest, ValidateSessionRequest, ValidateSessionResponse, ValidateTokenRequest, ValidateTokenResponse};
 use tonic::transport::Channel;
 
 pub struct AuthClient {
@@ -32,6 +32,15 @@ impl AuthClient {
         Ok(response.into_inner())
     }
 
+    pub async fn validate_session(&mut self, session_id: &str) -> Result<ValidateSessionResponse, Box<dyn std::error::Error + Send + Sync>> {
+        let request = ValidateSessionRequest {
+            session_id: session_id.to_string()
+        };
+
+        let response = self.client.validate_session(request).await?;
+        Ok(response.into_inner())
+    }
+
     pub async fn logout(&mut self, session_id: &str) -> Result<Empty, Box<dyn std::error::Error + Send + Sync>> {
         let request = LogoutRequest {
             session_id: session_id.to_string(),

packet-service/src/handlers/auth.rs

@@ -24,6 +24,7 @@ use tracing::{debug, error, info, warn};
 use utils::service_discovery;
 use crate::connection_service::ConnectionService;
 use crate::packets::cli_logout_req::CliLogoutReq;
+use crate::packets::srv_join_server_reply::SrvJoinServerReply;
 
 pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
     let data = SrvAcceptReply { result: srv_accept_reply::Result::Accepted, rand_value: 0 };
@@ -33,17 +34,37 @@ pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) ->
     Ok(())
 }
 
-pub(crate) async fn handle_join_server_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn handle_join_server_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliJoinServerTokenReq::decode(packet.payload.as_slice());
     debug!("{:?}", request);
-    Ok(())
+
+    if let Some(mut state) = connection_service.get_connection(&connection_id) {
+        let session_id = state.session_id.clone().unwrap();
+        let mut auth_client = auth_client.lock().await;
+        let session = auth_client.validate_session(&session_id).await?;
+        if (!session.valid) {
+            warn!("Invalid session ID: {}", session_id);
+            
+            let data = SrvJoinServerReply { result: srv_join_server_reply::Result::Failed, id: 0, pay_flag: 0 };
+            let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
+            send_packet(stream, &response_packet).await?;
+            return Err("Session not valid".into());
+        }
+        
+        let data = SrvJoinServerReply { result: srv_join_server_reply::Result::Ok, id: 1, pay_flag: 0 };
+        let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
+        send_packet(stream, &response_packet).await?;
+        Ok(())
+    } else {
+        Err("Unable to find connection state".into())
+    }
 }
 
 pub(crate) async fn handle_logout_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>, connection_service: Arc<ConnectionService>, connection_id: String) -> Result<(), Box<dyn Error + Send + Sync>> {
     let request = CliLogoutReq::decode(packet.payload.as_slice());
-    let mut auth_client = auth_client.lock().await;
     if let Some(mut state) = connection_service.get_connection(&connection_id) {
         let session_id = state.session_id.clone().unwrap();
+        let mut auth_client = auth_client.lock().await;
         auth_client.logout(&session_id).await?;
         Ok(())
     } else {
@@ -146,7 +167,7 @@ pub(crate) async fn handle_server_select_req(stream: &mut TcpStream, packet: Pac
     }
 
     let data = SrvSrvSelectReply {
-        result: srv_srv_select_reply::Result::Failed,
+        result: srv_srv_select_reply::Result::Ok,
         session_id: 0, // Client should already have this value
         crypt_val: 0, // This is only for the old encryption
         ip: NullTerminatedString::new(""), // If this is empty, the client should stay connected (requires client change)

packet-service/src/router.rs

@@ -14,7 +14,7 @@ pub async fn route_packet(stream: &mut TcpStream, packet: Packet, auth_client: A
     match packet.packet_type {
         PacketType::PakcsAlive => Ok(()),
         PacketType::PakcsAcceptReq => auth::handle_accept_req(stream, packet).await,
-        PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet).await,
+        PacketType::PakcsJoinServerTokenReq => auth::handle_join_server_req(stream, packet, auth_client, connection_service, connection_id).await,
         // Login Stuff 
         PacketType::PakcsLoginTokenReq => auth::handle_login_req(stream, packet, auth_client, connection_service, connection_id, stream.peer_addr()?).await,
         PacketType::PakcsLogoutReq => auth::handle_logout_req(stream, packet, auth_client, connection_service, connection_id).await,