diff --git a/packet-service/src/bufferpool.rs b/packet-service/src/bufferpool.rs index c4d7420..7d6d35c 100644 --- a/packet-service/src/bufferpool.rs +++ b/packet-service/src/bufferpool.rs @@ -2,7 +2,7 @@ use std::collections::VecDeque; use std::sync::Arc; use tokio::sync::{Semaphore, Mutex}; -const MAX_PACKET_SIZE: usize = 1024; +const MAX_PACKET_SIZE: usize = 0xFFF; pub struct BufferPool { buffers: Mutex>>, diff --git a/packet-service/src/handlers/character.rs b/packet-service/src/handlers/character.rs index c2f12e2..4cebcdd 100644 --- a/packet-service/src/handlers/character.rs +++ b/packet-service/src/handlers/character.rs @@ -1,9 +1,18 @@ -use utils::null_string::NullTerminatedString; +use crate::auth_client::AuthClient; +use crate::character_client::CharacterClient; +use crate::connection_service::ConnectionService; +use crate::dataconsts::*; +use crate::enums; use crate::packet::{send_packet, Packet, PacketPayload}; use crate::packet_type::PacketType; use crate::packets::cli_char_list_req::CliCharListReq; +use crate::packets::cli_create_char_req::CliCreateCharReq; +use crate::packets::cli_delete_char_req::CliDeleteCharReq; +use crate::packets::cli_select_char_req::CliSelectCharReq; +use crate::packets::srv_create_char_reply::SrvCreateCharReply; +use crate::packets::srv_delete_char_reply::SrvDeleteCharReply; +use crate::packets::srv_switch_server::SrvSwitchServer; use crate::packets::*; -use crate::dataconsts::*; use std::collections::HashMap; use std::env; use std::error::Error; @@ -12,15 +21,7 @@ use tokio::net::TcpStream; use tokio::sync::Mutex; use tonic::{Code, Status}; use tracing::{debug, error, info, warn}; -use crate::auth_client::AuthClient; -use crate::character_client::CharacterClient; -use crate::connection_service::ConnectionService; -use crate::enums; -use crate::packets::cli_create_char_req::CliCreateCharReq; -use crate::packets::cli_delete_char_req::CliDeleteCharReq; -use crate::packets::cli_select_char_req::CliSelectCharReq; -use crate::packets::srv_create_char_reply::SrvCreateCharReply; -use crate::packets::srv_delete_char_reply::SrvDeleteCharReply; +use utils::null_string::NullTerminatedString; fn convert_slot(slot: i32) -> srv_char_list_reply::EquippedPosition { match enums::EquippedPosition::from_i32(slot) { @@ -32,7 +33,7 @@ fn convert_slot(slot: i32) -> srv_char_list_reply::EquippedPosition { Some(enums::EquippedPosition::Boots) => srv_char_list_reply::EquippedPosition::Boots, Some(enums::EquippedPosition::WeaponR) => srv_char_list_reply::EquippedPosition::WeaponR, Some(enums::EquippedPosition::WeaponL) => srv_char_list_reply::EquippedPosition::WeaponL, - _ => srv_char_list_reply::EquippedPosition::MaxItems + _ => srv_char_list_reply::EquippedPosition::MaxItems, } } @@ -52,7 +53,7 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, let mut character_client = character_client.lock().await; let character_list = character_client.get_character_list(&user_id.to_string()).await?; let mut characters = vec![]; - let mut character_id_list:Vec = Vec::new(); + let mut character_id_list: Vec = Vec::new(); for character in character_list.characters { let mut item_list: [EquippedItem; (MAX_VISIBLE_ITEMS as usize)] = core::array::from_fn(|i| EquippedItem::default()); @@ -90,7 +91,7 @@ pub(crate) async fn handle_char_list_req(stream: &mut TcpStream, packet: Packet, let data = SrvCharListReply { characters }; let response_packet = Packet::new(PacketType::PakccCharListReply, &data)?; send_packet(stream, &response_packet).await?; - + Ok(()) } @@ -104,7 +105,7 @@ pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packe user_id = state.user_id.expect("Missing user id in connection state"); session_id = state.session_id.expect("Missing session id in connection state"); } - + // send the data to the character service to create the character let mut character_client = character_client.lock().await; let create_character_response = character_client.create_character(&user_id.to_string(), request.name, request.race, request.face, request.hair, request.stone).await?; @@ -116,9 +117,9 @@ pub(crate) async fn handle_create_char_req(stream: &mut TcpStream, packet: Packe 3 => srv_create_char_reply::Result::InvalidValue, 4 => srv_create_char_reply::Result::TooManyChars, 5 => srv_create_char_reply::Result::Blocked, - _ => srv_create_char_reply::Result::Failed + _ => srv_create_char_reply::Result::Failed, }; - + let data = SrvCreateCharReply { result, platininum: 0 }; let response_packet = Packet::new(PacketType::PakccCreateCharReply, &data)?; send_packet(stream, &response_packet).await?; @@ -132,8 +133,8 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe let mut user_id = 0; let session_id; - let mut character_id_list:Vec = Vec::new(); - + let mut character_id_list: Vec = Vec::new(); + if let Some(mut state) = connection_service.get_connection(&connection_id) { user_id = state.user_id.expect("Missing user id in connection state"); session_id = state.session_id.expect("Missing session id in connection state"); @@ -144,7 +145,10 @@ pub(crate) async fn handle_delete_char_req(stream: &mut TcpStream, packet: Packe let delete_response = character_client.delete_character(&user_id.to_string(), &character_id_list[request.char_id as usize].to_string(), request.is_delete as i32).await?; let character_name = request.name; - let data = SrvDeleteCharReply { remaining_time: delete_response.remaining_time as u32, name: character_name }; + let data = SrvDeleteCharReply { + remaining_time: delete_response.remaining_time as u32, + name: character_name, + }; let response_packet = Packet::new(PacketType::PakccDeleteCharReply, &data)?; send_packet(stream, &response_packet).await?; @@ -155,19 +159,29 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe use crate::packets::srv_select_char_reply::*; use crate::packets::srv_inventory_data::*; use crate::packets::srv_quest_data::*; + use crate::packets::srv_select_char_reply::*; use crate::packets::srv_billing_message::*; use crate::types::{HotbarItem, StatusEffect}; let request = CliSelectCharReq::decode(packet.payload.as_slice())?; debug!("{:?}", request); let mut user_id = 0; - let mut character_id_list:Vec = Vec::new(); + let mut character_id_list: Vec = Vec::new(); if let Some(mut state) = connection_service.get_connection_mut(&connection_id) { user_id = state.user_id.expect("Missing user id in connection state"); character_id_list = state.character_list.clone().expect("Missing character id list"); state.character_id = Some(request.char_id as i8); } + let data = SrvSwitchServer { + port: 0, + session_id: 0, + session_seed: 0, + ip: NullTerminatedString("".to_string()), + }; + let response_packet = Packet::new(PacketType::PakccSwitchServer, &data)?; + send_packet(stream, &response_packet).await?; + let mut character_client = character_client.lock().await; let character_data = character_client.get_character(&user_id.to_string(), character_id_list[request.char_id as usize]).await?; @@ -195,7 +209,7 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe header: srv_inventory_data::Header { type_: item.item_type as u8, id: item.item_id as u16, - is_created:item.is_created as u8, + is_created: item.is_created as u8, }, data: srv_inventory_data::Data { gem_opt: item.gem_option as u16, @@ -214,8 +228,8 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe let data = SrvSelectCharReply { race: looks.race as u8, map: position.map_id as u16, - x: position.x, - y: position.y, + x: position.x * 100.0, + y: position.y * 100.0, spawn: position.spawn_id as u16, body_face: looks.face as u32, body_hair: looks.hair as u32, @@ -254,7 +268,7 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe pat_cooldown_time: stats.pat_cooldown_time as u32, skills: [0u16; (MAX_SKILL_COUNT as usize)], hotbar: hotbar_list, - tag: 0, + tag: user_id as u32, name: request.name, }; let response_packet = Packet::new(PacketType::PakwcSelectCharReply, &data)?; @@ -281,7 +295,7 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe switches: [0; (MAX_SWITCHES as usize)], wishlist, }; - let response_packet = Packet::new(PacketType::PakwcInventoryData, &data)?; + let response_packet = Packet::new(PacketType::PakwcQuestData, &data)?; send_packet(stream, &response_packet).await?; // Send the billing message (we don't actually use this so we just send the defaults to allow) @@ -293,4 +307,4 @@ pub(crate) async fn handle_select_char_req(stream: &mut TcpStream, packet: Packe send_packet(stream, &response_packet).await?; Ok(()) -} \ No newline at end of file +} diff --git a/packet-service/src/packet.rs b/packet-service/src/packet.rs index e1ef946..02070e2 100644 --- a/packet-service/src/packet.rs +++ b/packet-service/src/packet.rs @@ -1,9 +1,9 @@ -use bincode::{Encode, Decode}; +use crate::packet_type::PacketType; +use bincode::{Decode, Encode}; use std::error::Error; use tokio::io::AsyncWriteExt; use tokio::net::TcpStream; use tracing::{debug, error}; -use crate::packet_type::PacketType; #[derive(Debug)] pub struct Packet { @@ -15,8 +15,7 @@ pub struct Packet { pub trait PacketPayload: Encode + Decode { fn encode(&self) -> Result, Box> { - let config = bincode::config::standard() - .with_fixed_int_encoding(); + let config = bincode::config::standard().with_fixed_int_encoding(); Ok(bincode::encode_to_vec(self, config)?) } @@ -24,8 +23,7 @@ pub trait PacketPayload: Encode + Decode { where Self: Sized, { - let config = bincode::config::standard() - .with_fixed_int_encoding(); + let config = bincode::config::standard().with_fixed_int_encoding(); Ok(bincode::decode_from_slice(data, config)?.0) } } @@ -47,6 +45,7 @@ impl Packet { pub fn from_raw(data: &[u8]) -> Result> { if data.len() < 6 { + error!("Invalid packet: Size too small {}", data.len()); return Err("Invalid packet: Too short".into()); } @@ -56,18 +55,26 @@ impl Packet { let packet_crc = u16::from_le_bytes(data[4..6].try_into()?); // Validate the size - if packet_size as usize != data.len() { - error!("Invalid packet: Size mismatch, expected: {}, actual: {}", packet_size, data.len()); + if packet_size as usize > data.len() { + error!( + "Invalid packet {:#X}: Size mismatch, expected: {}, received: {}", + raw_packet_type, + packet_size, + data.len() + ); return Err("Invalid packet: Size mismatch".into()); } - - debug!("size: {:#X}, raw_type: {:#X}, crc: {:#X}", packet_size, raw_packet_type, packet_crc); + + debug!( + "size: {:#X}, raw_type: {:#X}, crc: {:#X}", + packet_size, raw_packet_type, packet_crc + ); // Convert raw packet type into `PacketType` enum let packet_type = PacketType::try_from(raw_packet_type)?; // Extract the payload - let payload = data[6..].to_vec(); + let payload = data[6..packet_size as usize].to_vec(); Ok(Self { packet_size, @@ -89,7 +96,7 @@ impl Packet { raw } - + pub fn parse(&self) -> Result> { ::decode(&self.payload) } diff --git a/packet-service/src/router.rs b/packet-service/src/router.rs index 1484983..a12d704 100644 --- a/packet-service/src/router.rs +++ b/packet-service/src/router.rs @@ -25,14 +25,24 @@ impl PacketRouter { ACTIVE_CONNECTIONS.inc(); while let Some(mut buffer) = pool.acquire().await { // Read data into the buffer - let n = stream.read(&mut buffer).await?; + let mut header_handle = stream.take(6); + let n = header_handle.read(&mut buffer).await?; if n == 0 { break; // Connection closed } + let packet_size = u16::from_le_bytes(buffer[0..2].try_into()?) as usize; + if packet_size > 6 { + let mut body_handle = stream.take((packet_size-6) as u64); + let n = body_handle.read(&mut buffer[6..]).await?; + if n == 0 { + break; // Connection closed + } + } + PACKETS_RECEIVED.inc(); // Process the packet - match Packet::from_raw(&buffer[..n]) { + match Packet::from_raw(&buffer[..packet_size]) { Ok(packet) => { debug!("Parsed Packet: {:?}", packet); // Handle the parsed packet (route it, process it, etc.)