use std::net; use rand::{Rng, RngCore}; use bcrypt::{DEFAULT_COST, hash, verify}; use libpso::packet::login::*; use libpso::{PacketParseError, PSOPacket}; use libpso::crypto::{CipherError, PSOCipher, NullCipher}; use libpso::crypto::bb::PSOBBCipher; use elseware::pktvec; use elseware::common::pktvec::PktVec; use elseware::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY}; use elseware::common::network::{PacketNetworkError}; use elseware::common::client::Client; use elseware::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect}; use elseware::common::util::array_to_utf8; use crate::dataaccess::DataAccess; use crate::login::{SharedLoginState, get_login_status}; use crate::models::UserAccount; pub const CHARACTER_PORT: u16 = 12001; #[derive(Debug)] pub enum CharacterError { } #[derive(Debug)] pub enum RecvCharacterPacket { Login(Login), RequestSettings(RequestSettings), } impl RecvServerPacket for RecvCharacterPacket { fn from_bytes(data: &Vec) -> Result { match data[2] { 0x93 => Ok(RecvCharacterPacket::Login(Login::from_bytes(data)?)), 0xE0 => Ok(RecvCharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)), _ => Err(PacketParseError::WrongPacketForServerType) } } } #[derive(Debug)] pub enum SendCharacterPacket { LoginResponse(LoginResponse), LoginWelcome(LoginWelcome), SendKeyAndTeamSettings(SendKeyAndTeamSettings), } impl SendServerPacket for SendCharacterPacket { fn as_bytes(&self) -> Vec { match self { SendCharacterPacket::LoginResponse(pkt) => pkt.as_bytes(), SendCharacterPacket::LoginWelcome(pkt) => pkt.as_bytes(), SendCharacterPacket::SendKeyAndTeamSettings(pkt) => pkt.as_bytes(), //SendLoginPacket::RedirectClient(pkt) => pkt.as_bytes(), } } } pub struct CharacterServerState { shared_state: SharedLoginState, user: Option, } impl CharacterServerState { fn new(shared_state: SharedLoginState) -> CharacterServerState { CharacterServerState { shared_state: shared_state, user: None, } } fn validate_login(&mut self, pkt: &Login) -> Vec { match get_login_status(&self.shared_state.data_access, pkt) { Ok(user) => { let mut response = LoginResponse::by_status(AccountStatus::Ok, pkt.security_data); response.guildcard = user.guildcard.map_or(0, |gc| gc) as u32; response.team_id = user.team_id.map_or(0, |ti| ti) as u32; self.user = Some(user); vec![SendCharacterPacket::LoginResponse(response)] }, Err(err) => { vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, pkt.security_data))] } } } fn get_settings(&mut self) -> Vec { let user = self.user.as_ref().unwrap(); let settings = match self.shared_state.data_access.get_user_settings_by_user(&user) { Some(settings) => settings, None => self.shared_state.data_access.create_user_settings_by_user(&user), }; let pkt = SendKeyAndTeamSettings::new(settings.settings.key_config, settings.settings.joystick_config, 0, 0); let pkt = SendCharacterPacket::SendKeyAndTeamSettings(pkt); vec![pkt] } } impl ServerState for CharacterServerState { type SendPacket = SendCharacterPacket; type RecvPacket = RecvCharacterPacket; type PacketError = CharacterError; fn on_connect(&mut self) -> Vec> { let mut rng = rand::thread_rng(); let mut server_key = [0u8; 48]; let mut client_key = [0u8; 48]; rng.fill(&mut server_key[..]); rng.fill(&mut client_key[..]); vec![OnConnect::Packet(SendCharacterPacket::LoginWelcome(LoginWelcome::new(server_key, client_key))), OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)), Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key)))) ] } fn handle(&mut self, pkt: &RecvCharacterPacket) -> Box> { match pkt { RecvCharacterPacket::Login(login) => { Box::new(self.validate_login(login).into_iter()) }, RecvCharacterPacket::RequestSettings(_req) => { Box::new(self.get_settings().into_iter()) } } } } pub fn new_client(socket: mio::tcp::TcpStream, shared_state: SharedLoginState) { let state = CharacterServerState::new(shared_state); let client = Client::new(socket, Box::new(state)); client.io_loop(); } #[cfg(test)] mod test { use super::*; use crate::models::{EUserSettings, UserSettings}; use libpso::character::settings; use std::time::SystemTime; #[test] fn test_login() { } #[test] fn test_option_send() { struct TestData { } impl DataAccess for TestData { fn get_user_settings_by_user(&self, _user: &UserAccount) -> Option { Some(UserSettings { id: 0, user_id: 0, settings: EUserSettings(settings::UserSettings::default()) }) } } let shared = SharedLoginState::new(TestData {}); let mut server = CharacterServerState::new(shared); server.user = Some(UserAccount { id: 1, username: "testuser".to_owned(), password: bcrypt::hash("mypassword", 5).unwrap(), guildcard: None, team_id: None, banned: false, muted_until: SystemTime::now(), created_at: SystemTime::now(), }); let send = server.handle(&RecvCharacterPacket::RequestSettings(RequestSettings {flag: 0})).collect::>(); assert!(send.len() == 1); let bytes = send[0].as_bytes(); assert!(bytes[2] == 0xE2); assert!(bytes.len() == 0xAFC); } }