Raven/osirose-new
SHA256
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 6 Releases Wiki Activity

Refactor

Browse Source 
Updated handlers by spliting the TcpStream in half to allow reading and writing data at the same time.
This fixes an issue where you are unable to get chat messages until the client sends a packet to the server

Fixed client id's by adding the id manager
Added shout chat handling
This commit is contained in:
raven
2025-06-07 00:36:02 -04:00
parent d4dadf5170
commit aa2be43f4e
17 changed files with 480 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
packet-service/src/handlers/auth.rs
View File

@@ -20,7 +20,6 @@ use crate::handlers::chat::create_chat_client_handler;
use crate::handlers::chat_client::ChatClientHandler;
pub(crate) async fn handle_alive_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
@@ -42,8 +41,9 @@ pub(crate) async fn handle_alive_req(
}
pub(crate) async fn handle_accept_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
connection_service: Arc<ConnectionService>,
connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::srv_accept_reply::SrvAcceptReply;
let data = SrvAcceptReply {
@@ -52,13 +52,15 @@ pub(crate) async fn handle_accept_req(
};
let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
Ok(())
}
pub(crate) async fn handle_join_server_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
@@ -82,19 +84,26 @@ pub(crate) async fn handle_join_server_req(
pay_flag: 0,
};
let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
return Err("Session not valid".into());
}
let client_id = state.client_id.clone();
let data = SrvJoinServerReply {
result: srv_join_server_reply::Result::Ok,
id: 1,
id: client_id as u32,
pay_flag: 0,
};
let response_packet = Packet::new(PacketType::PakscJoinServerReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
Ok(())
} else {
Err("Unable to find connection state".into())
@@ -102,7 +111,6 @@ pub(crate) async fn handle_join_server_req(
}
pub(crate) async fn handle_logout_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
@@ -116,9 +124,12 @@ pub(crate) async fn handle_logout_req(
let data = SrvLogoutReply { wait_time: 1 };
let response_packet = Packet::new(PacketType::PakwcLogoutReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
locked_stream.shutdown().await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
locked_stream.shutdown().await?;
}
Ok(())
} else {
Err("Unable to find connection state".into())
@@ -126,7 +137,6 @@ pub(crate) async fn handle_logout_req(
}
pub(crate) async fn handle_login_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
auth_client: Arc<Mutex<AuthClient>>,
connection_service: Arc<ConnectionService>,
@@ -152,14 +162,20 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
} else {
debug!("Successfully logged in");
let mut client_id = 0;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
state.user_id = Some(response.user_id);
state.session_id = Some(response.session_id.clone());
client_id = connection_service.next_id();
state.client_id = client_id;
}
let chat_url = format!(
@@ -171,10 +187,13 @@ pub(crate) async fn handle_login_req(
.unwrap()
);
let handler = ChatClientHandler::new(chat_url, connection_id.clone(), response.session_id.clone()).await?;
let handler = ChatClientHandler::new(chat_url, client_id.to_string(), response.session_id.clone()).await?;
let chat_handler = Arc::new(handler);
create_chat_client_handler(stream.clone(), chat_handler.clone()).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
create_chat_client_handler(writer_clone, chat_handler.clone()).await?;
}
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
state.chat_handler = Some(chat_handler);
@@ -216,8 +235,11 @@ pub(crate) async fn handle_login_req(
servers_info: server_info,
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
}
Err(err) => {
@@ -229,8 +251,11 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
return Ok(());
}
}
@@ -249,8 +274,11 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
Code::Unavailable => {
warn!("Login failed: Service is unavailable");
@@ -261,8 +289,11 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
_ => {
error!("Unexpected error: {}", tonic_status.message());
@@ -273,8 +304,11 @@ pub(crate) async fn handle_login_req(
servers_info: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
}
}
@@ -285,7 +319,6 @@ pub(crate) async fn handle_login_req(
}
pub(crate) async fn handle_server_select_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
connection_service: Arc<ConnectionService>,
connection_id: String,
@@ -313,14 +346,18 @@ pub(crate) async fn handle_server_select_req(
};
let response_packet = Packet::new(PacketType::PaklcSrvSelectReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
Ok(())
}
pub(crate) async fn handle_channel_list_req(
stream: Arc<Mutex<TcpStream>>,
packet: Packet,
connection_service: Arc<ConnectionService>,
connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
use crate::packets::cli_channel_list_req::CliChannelListReq;
use crate::packets::srv_channel_list_reply::{ChannelInfo, SrvChannelListReply};
@@ -356,8 +393,11 @@ pub(crate) async fn handle_channel_list_req(
channels: channel_info,
};
let response_packet = Packet::new(PacketType::PaklcChannelListReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
}
}
Err(err) => {
@@ -366,8 +406,11 @@ pub(crate) async fn handle_channel_list_req(
channels: Vec::new(),
};
let response_packet = Packet::new(PacketType::PaklcChannelListReply, &data)?;
let mut locked_stream = stream.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
let writer_clone = state.writer.clone().unwrap();
let mut locked_stream = writer_clone.lock().await;
send_packet(&mut locked_stream, &response_packet).await?;
}
return Ok(());
}
}