495 lines
20 KiB
Rust
495 lines
20 KiB
Rust
use std::io::Read;
|
|
use std::collections::HashMap;
|
|
|
|
use rand::Rng;
|
|
use crc::{crc32, Hasher32};
|
|
|
|
use libpso::packet::login::*;
|
|
use libpso::{PacketParseError, PSOPacket};
|
|
use libpso::crypto::bb::PSOBBCipher;
|
|
|
|
use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
|
|
use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
|
|
use crate::{utf8_to_array, utf8_to_utf16_array};
|
|
|
|
use crate::entity::gateway::EntityGateway;
|
|
use crate::entity::account::{UserAccount, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
|
|
use crate::entity::character::Character;
|
|
|
|
use crate::login::login::get_login_status;
|
|
|
|
pub const CHARACTER_PORT: u16 = 12001;
|
|
|
|
#[derive(Debug)]
|
|
pub enum CharacterError {
|
|
ClientNotFound(ClientId),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RecvCharacterPacket {
|
|
Login(Login),
|
|
RequestSettings(RequestSettings),
|
|
CharSelect(CharSelect),
|
|
Checksum(Checksum),
|
|
GuildcardDataRequest(GuildcardDataRequest),
|
|
GuildcardDataChunkRequest(GuildcardDataChunkRequest),
|
|
ParamDataRequest(ParamDataRequest),
|
|
ParamDataChunkRequest(ParamDataChunkRequest),
|
|
CharacterPreview(CharacterPreview),
|
|
SetFlag(SetFlag)
|
|
}
|
|
|
|
impl RecvServerPacket for RecvCharacterPacket {
|
|
fn from_bytes(data: &[u8]) -> Result<RecvCharacterPacket, PacketParseError> {
|
|
match u16::from_le_bytes([data[2], data[3]]) {
|
|
0x93 => Ok(RecvCharacterPacket::Login(Login::from_bytes(data)?)),
|
|
0xE0 => Ok(RecvCharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)),
|
|
0xE3 => Ok(RecvCharacterPacket::CharSelect(CharSelect::from_bytes(data)?)),
|
|
0x1E8 => Ok(RecvCharacterPacket::Checksum(Checksum::from_bytes(data)?)),
|
|
0x3E8 => Ok(RecvCharacterPacket::GuildcardDataRequest(GuildcardDataRequest::from_bytes(data)?)),
|
|
0x3DC => Ok(RecvCharacterPacket::GuildcardDataChunkRequest(GuildcardDataChunkRequest::from_bytes(data)?)),
|
|
0x4EB => Ok(RecvCharacterPacket::ParamDataRequest(ParamDataRequest::from_bytes(data)?)),
|
|
0x3EB => Ok(RecvCharacterPacket::ParamDataChunkRequest(ParamDataChunkRequest::from_bytes(data)?)),
|
|
0xE5 => Ok(RecvCharacterPacket::CharacterPreview(CharacterPreview::from_bytes(data)?)),
|
|
0xEC => Ok(RecvCharacterPacket::SetFlag(SetFlag::from_bytes(data)?)),
|
|
_ => Err(PacketParseError::WrongPacketForServerType)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Debug)]
|
|
pub enum SendCharacterPacket {
|
|
LoginResponse(LoginResponse),
|
|
LoginWelcome(LoginWelcome),
|
|
SendKeyAndTeamSettings(SendKeyAndTeamSettings),
|
|
CharAck(CharAck),
|
|
ChecksumAck(ChecksumAck),
|
|
CharacterPreview(CharacterPreview),
|
|
GuildcardDataHeader(GuildcardDataHeader),
|
|
GuildcardDataChunk(GuildcardDataChunk),
|
|
ParamDataHeader(ParamDataHeader),
|
|
ParamDataChunk(ParamDataChunk),
|
|
Timestamp(Timestamp),
|
|
ShipList(ShipList)
|
|
}
|
|
|
|
impl SendServerPacket for SendCharacterPacket {
|
|
fn as_bytes(&self) -> Vec<u8> {
|
|
match self {
|
|
SendCharacterPacket::LoginResponse(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::LoginWelcome(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::SendKeyAndTeamSettings(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::CharAck(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ChecksumAck(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::CharacterPreview(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::GuildcardDataHeader(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::GuildcardDataChunk(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ParamDataHeader(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ParamDataChunk(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::Timestamp(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ShipList(pkt) => pkt.as_bytes(),
|
|
//SendLoginPacket::RedirectClient(pkt) => pkt.as_bytes(),
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fn generate_param_data(path: &str) -> (ParamDataHeader, Vec<u8>) {
|
|
let paths = std::fs::read_dir(path).expect("could not find param/ directory");
|
|
|
|
let mut files = Vec::new();
|
|
let mut buffer = Vec::new();
|
|
for p in paths {
|
|
let param = p.unwrap().path();
|
|
let mut file = std::fs::File::open(¶m).unwrap();
|
|
|
|
let mut filebuf = Vec::new();
|
|
let len = file.read_to_end(&mut filebuf).unwrap();
|
|
|
|
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|
crc.write(&filebuf[..]);
|
|
|
|
files.push(ParamFile {
|
|
size: len as u32,
|
|
checksum: crc.sum32(),
|
|
offset: buffer.len() as u32,
|
|
filename: utf8_to_array!(param.file_name().unwrap().to_str().unwrap(), 0x40),
|
|
});
|
|
|
|
buffer.append(&mut filebuf);
|
|
}
|
|
|
|
(ParamDataHeader {
|
|
files: files
|
|
}, buffer)
|
|
}
|
|
|
|
struct ClientState {
|
|
param_index: usize,
|
|
user: Option<UserAccount>,
|
|
characters: Option<[Option<Character>; 4]>,
|
|
guildcard_data_buffer: Option<Vec<u8>>,
|
|
security_data: [u8; 40],
|
|
}
|
|
|
|
impl ClientState {
|
|
fn new() -> ClientState {
|
|
ClientState {
|
|
param_index: 0,
|
|
user: None,
|
|
characters: None,
|
|
guildcard_data_buffer: None,
|
|
security_data: [0; 40],
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Ship {
|
|
flags: u32,
|
|
name: String,
|
|
ip: [u8; 4],
|
|
port: u16,
|
|
}
|
|
|
|
impl Ship {
|
|
fn new(name: &str, ip: [u8; 4], port: u16) -> Ship {
|
|
Ship {
|
|
flags: 0,
|
|
name: name.to_owned(),
|
|
ip: ip,
|
|
port: port,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct CharacterServerState<EG: EntityGateway> {
|
|
entity_gateway: EG,
|
|
param_header: ParamDataHeader,
|
|
param_data: Vec<u8>,
|
|
clients: HashMap<ClientId, ClientState>,
|
|
ships: Vec<Ship>,
|
|
}
|
|
|
|
impl<EG: EntityGateway> CharacterServerState<EG> {
|
|
pub fn new(entity_gateway: EG) -> CharacterServerState<EG> {
|
|
let (param_header, param_data) = generate_param_data("param/");
|
|
|
|
let ships = vec![Ship::new("Sona-Nyl", [127,0,0,1], 23423),
|
|
Ship::new("Dylath-Leen", [127,0,0,1], 23424),
|
|
Ship::new("Thalarion", [127,0,0,1], 23425),
|
|
];
|
|
CharacterServerState {
|
|
//shared_state: shared_state,
|
|
entity_gateway: entity_gateway,
|
|
param_header: param_header,
|
|
param_data: param_data,
|
|
clients: HashMap::new(),
|
|
ships: ships,
|
|
}
|
|
}
|
|
|
|
fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
Ok(match get_login_status(&self.entity_gateway, pkt) {
|
|
Ok(user) => {
|
|
let mut response = LoginResponse::by_status(AccountStatus::Ok, [0; 40]);
|
|
response.guildcard = user.guildcard.map_or(0, |gc| gc) as u32;
|
|
response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
|
|
client.user = Some(user);
|
|
client.security_data = pkt.security_data;
|
|
vec![SendCharacterPacket::LoginResponse(response)]
|
|
},
|
|
Err(err) => {
|
|
vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, [0; 40]))]
|
|
}
|
|
})
|
|
}
|
|
|
|
fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
Ok(vec![SendCharacterPacket::Timestamp(Timestamp::new(chrono::Utc::now())),
|
|
SendCharacterPacket::ShipList(ShipList {
|
|
flag: 0,
|
|
ships: self.ships.iter().enumerate().map(|(i, s)| {
|
|
ShipListEntry {
|
|
menu: 0,
|
|
item: i as u32,
|
|
flags: 0,
|
|
name: utf8_to_utf16_array!(s.name, 0x11)
|
|
}
|
|
}).collect()
|
|
})])
|
|
}
|
|
|
|
fn get_settings(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
let user = client.user.as_ref().unwrap();
|
|
|
|
// TODO: this should error (data should be added on account creation, why did I copy this silly sylv logic?)
|
|
let settings = match self.entity_gateway.get_user_settings_by_user(&user) {
|
|
Some(settings) => settings,
|
|
None => self.entity_gateway.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);
|
|
|
|
Ok(vec![pkt])
|
|
}
|
|
|
|
fn char_select(&mut self, id: ClientId, select: &CharSelect) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
if client.characters.is_none() {
|
|
client.characters = Some(self.entity_gateway.get_characters_by_user(client.user.as_ref().unwrap()));
|
|
}
|
|
|
|
if select.reason == 0 {
|
|
let chars = client.characters.as_ref().unwrap();
|
|
Ok(if let Some(char) = &chars[select.slot as usize] {
|
|
vec![SendCharacterPacket::CharacterPreview(CharacterPreview {
|
|
flag: 0,
|
|
slot: select.slot,
|
|
character: char.character.as_select_screen(),
|
|
})]
|
|
}
|
|
else {
|
|
vec![SendCharacterPacket::CharAck(CharAck {
|
|
flag: 0,
|
|
slot: select.slot,
|
|
code: 2,
|
|
})]
|
|
})
|
|
}
|
|
else {
|
|
let user = client.user.as_ref().unwrap();
|
|
client.security_data[0..4].clone_from_slice(&[1,3,3,7]);
|
|
client.security_data[4] = select.slot as u8;
|
|
client.security_data[5] = 1;
|
|
Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard.unwrap_or(1),
|
|
user.team_id.unwrap_or(1),
|
|
client.security_data)),
|
|
SendCharacterPacket::CharAck(CharAck {
|
|
flag: 0,
|
|
slot: select.slot,
|
|
code: 1,
|
|
})
|
|
])
|
|
}
|
|
}
|
|
|
|
fn validate_checksum(&mut self) -> Vec<SendCharacterPacket> {
|
|
vec![SendCharacterPacket::ChecksumAck(ChecksumAck {
|
|
flag: 0,
|
|
ack: 1,
|
|
})]
|
|
}
|
|
|
|
fn guildcard_data_header(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
let guildcard_data = self.entity_gateway.get_guild_card_data_by_user(client.user.as_ref().unwrap());
|
|
|
|
let bytes = guildcard_data.guildcard.as_bytes();
|
|
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|
crc.write(&bytes[..]);
|
|
client.guildcard_data_buffer = Some(bytes.to_vec());
|
|
|
|
Ok(vec![SendCharacterPacket::GuildcardDataHeader(GuildcardDataHeader::new(bytes.len(), crc.sum32()))])
|
|
}
|
|
|
|
fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, CharacterError> {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
Ok(if again != 0 {
|
|
let start = chunk as usize * GUILD_CARD_CHUNK_SIZE;
|
|
let len = std::cmp::min(GUILD_CARD_CHUNK_SIZE, client.guildcard_data_buffer.as_ref().unwrap().len() as usize - start);
|
|
let end = start + len;
|
|
|
|
let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE as usize];
|
|
buf[..len as usize].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);
|
|
|
|
vec![SendCharacterPacket::GuildcardDataChunk(GuildcardDataChunk::new(chunk, buf, len))]
|
|
} else {
|
|
Vec::new()
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
impl<EG: EntityGateway> ServerState for CharacterServerState<EG> {
|
|
type SendPacket = SendCharacterPacket;
|
|
type RecvPacket = RecvCharacterPacket;
|
|
type PacketError = CharacterError;
|
|
|
|
fn on_connect(&mut self, id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
|
|
self.clients.insert(id, ClientState::new());
|
|
|
|
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, id: ClientId, pkt: &RecvCharacterPacket)
|
|
-> Result<Box<dyn Iterator<Item = (ClientId, SendCharacterPacket)>>, CharacterError> {
|
|
Ok(match pkt {
|
|
RecvCharacterPacket::Login(login) => {
|
|
if login.security_data[0..4] == [1,3,3,7] {
|
|
Box::new(self.send_ship_list(id, login)?.into_iter().map(move |pkt| (id, pkt)))
|
|
}
|
|
else {
|
|
Box::new(self.validate_login(id, login)?.into_iter().map(move |pkt| (id, pkt)))
|
|
}
|
|
},
|
|
RecvCharacterPacket::RequestSettings(_req) => {
|
|
Box::new(self.get_settings(id)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::CharSelect(sel) => {
|
|
Box::new(self.char_select(id, sel)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::Checksum(_checksum) => {
|
|
Box::new(self.validate_checksum().into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::GuildcardDataRequest(_request) => {
|
|
Box::new(self.guildcard_data_header(id)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::GuildcardDataChunkRequest(request) => {
|
|
Box::new(self.guildcard_data_chunk(id, request.chunk, request.again)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::ParamDataRequest(_request) => {
|
|
Box::new(vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::SetFlag(flags) => {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
let mut user = client.user.as_mut().unwrap();
|
|
user.flags = flags.flags;
|
|
self.entity_gateway.set_user(&user);
|
|
Box::new(None.into_iter())
|
|
},
|
|
RecvCharacterPacket::ParamDataChunkRequest(_request) => {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
let chunk = client.param_index;
|
|
client.param_index += 1;
|
|
|
|
let start = chunk * 0x6800;
|
|
let end = std::cmp::min((chunk+1)*0x6800, self.param_data.len());
|
|
|
|
let mut data = [0u8; 0x6800];
|
|
data[..end-start].copy_from_slice(&self.param_data[start..end]);
|
|
|
|
Box::new(vec![SendCharacterPacket::ParamDataChunk(
|
|
ParamDataChunk {
|
|
flag: 0,
|
|
chunk: chunk as u32,
|
|
data: data,
|
|
}
|
|
)].into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvCharacterPacket::CharacterPreview(preview) => {
|
|
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
|
|
let mut user = client.user.as_mut().unwrap();
|
|
if user.flags == USERFLAG_NEWCHAR {
|
|
let mut char = self.entity_gateway.new_character_by_user(&user);
|
|
char.slot = preview.slot;
|
|
char.character = preview.character.as_character();
|
|
let char = Character {
|
|
id: 9,
|
|
slot: preview.slot,
|
|
user_id: user.id,
|
|
character: preview.character.as_character()
|
|
};
|
|
self.entity_gateway.set_character(&char);
|
|
}
|
|
if user.flags == USERFLAG_DRESSINGROOM {
|
|
// TODO: dressing room stuff
|
|
}
|
|
|
|
client.security_data[0..4].clone_from_slice(&[1,3,3,7]);
|
|
client.security_data[4] = preview.slot as u8;
|
|
client.security_data[5] = 1;
|
|
user.flags = 0;
|
|
self.entity_gateway.set_user(&user);
|
|
Box::new(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard.unwrap_or(0),
|
|
user.team_id.unwrap_or(0),
|
|
client.security_data)),
|
|
SendCharacterPacket::CharAck(CharAck {
|
|
flag: 0,
|
|
slot: preview.slot,
|
|
code: 0
|
|
})
|
|
].into_iter().map(move |pkt| (id, pkt)))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::entity::account::UserSettings;
|
|
use libpso::character::settings;
|
|
use std::time::SystemTime;
|
|
|
|
#[test]
|
|
fn test_option_send() {
|
|
struct TestData {
|
|
}
|
|
|
|
impl EntityGateway for TestData {
|
|
fn get_user_settings_by_user(&self, _user: &UserAccount) -> Option<UserSettings> {
|
|
Some(UserSettings {
|
|
id: 0,
|
|
user_id: 0,
|
|
settings: settings::UserSettings::default()
|
|
})
|
|
}
|
|
}
|
|
|
|
let mut server = CharacterServerState::new(TestData {});
|
|
let mut clientstate = ClientState::new();
|
|
clientstate.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(),
|
|
flags: 0,
|
|
});
|
|
server.clients.insert(ClientId(5), clientstate);
|
|
|
|
let send = server.handle(ClientId(5), &RecvCharacterPacket::RequestSettings(RequestSettings {flag: 0}))
|
|
.unwrap()
|
|
.collect::<Vec<_>>();
|
|
assert!(send.len() == 1);
|
|
|
|
assert!(send[0].0 == ClientId(5));
|
|
let bytes = send[0].1.as_bytes();
|
|
assert!(bytes[2] == 0xE2);
|
|
assert!(bytes.len() == 0xAFC);
|
|
}
|
|
|
|
#[test]
|
|
fn test_user_checksum() {
|
|
struct TestData;
|
|
impl EntityGateway for TestData {}
|
|
let mut server = CharacterServerState::new(TestData {});
|
|
let send = server.handle(ClientId(1), &RecvCharacterPacket::Checksum(Checksum {flag: 0,
|
|
checksum: 1234,
|
|
padding: 0,
|
|
})).unwrap().collect::<Vec<_>>();
|
|
assert!(send.len() == 1);
|
|
|
|
let bytes = send[0].1.as_bytes();
|
|
assert!(bytes == [0xC, 0, 0xE8, 0x02, 0,0,0,0, 1,0,0,0]);
|
|
}
|
|
}
|