2 changed files with 374 additions and 376 deletions
-
378src/patch/main.rs
-
372src/patch/patch.rs
@ -0,0 +1,372 @@ |
|||
use std::collections::{HashMap, HashSet};
|
|||
use std::fs;
|
|||
use std::io;
|
|||
use std::io::{Read};
|
|||
use std::path::PathBuf;
|
|||
use rand::Rng;
|
|||
use crc::{crc32, Hasher32};
|
|||
use libpso::{PacketParseError, PSOPacket};
|
|||
use libpso::packet::patch::*;
|
|||
use libpso::crypto::pc::PSOPCCipher;
|
|||
use elseware::common::network::{PacketNetworkError};
|
|||
use elseware::common::serverstate::{RecvServerPacket, SendServerPacket, ServerState, OnConnect, ClientId};
|
|||
|
|||
pub const PATCH_PORT: u16 = 11000;
|
|||
|
|||
#[derive(Debug)]
|
|||
pub enum PatchError {
|
|||
PacketNetworkError(PacketNetworkError),
|
|||
IOError(std::io::Error),
|
|||
}
|
|||
|
|||
impl From<PacketNetworkError> for PatchError {
|
|||
fn from(err: PacketNetworkError) -> PatchError {
|
|||
PatchError::PacketNetworkError(err)
|
|||
}
|
|||
}
|
|||
|
|||
impl From<std::io::Error> for PatchError {
|
|||
fn from(err: std::io::Error) -> PatchError {
|
|||
PatchError::IOError(err)
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct PatchFile {
|
|||
path: PathBuf,
|
|||
checksum: u32,
|
|||
size: u32,
|
|||
}
|
|||
|
|||
pub enum PatchTreeIterItem {
|
|||
Directory(PathBuf),
|
|||
File(PathBuf, u32),
|
|||
UpDirectory,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum PatchFileTree {
|
|||
Directory(PathBuf, Vec<PatchFileTree>),
|
|||
File(PathBuf, u32), // file_id
|
|||
}
|
|||
|
|||
impl PatchFileTree {
|
|||
fn iter_dir(tree: &PatchFileTree) -> Vec<PatchTreeIterItem> {
|
|||
let mut v = Vec::new();
|
|||
|
|||
match tree {
|
|||
PatchFileTree::Directory(dir, files) => {
|
|||
v.push(PatchTreeIterItem::Directory(dir.clone()));
|
|||
for file in files {
|
|||
v.append(&mut PatchFileTree::iter_dir(&file));
|
|||
}
|
|||
v.push(PatchTreeIterItem::UpDirectory);
|
|||
},
|
|||
PatchFileTree::File(path, id) => {
|
|||
v.push(PatchTreeIterItem::File(path.clone(), *id));
|
|||
}
|
|||
}
|
|||
|
|||
v
|
|||
}
|
|||
|
|||
pub fn flatten(&self) -> Vec<PatchTreeIterItem> {
|
|||
PatchFileTree::iter_dir(self)
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Debug)]
|
|||
pub enum RecvPatchPacket {
|
|||
PatchWelcomeReply(PatchWelcomeReply),
|
|||
LoginReply(LoginReply),
|
|||
FileInfoReply(FileInfoReply),
|
|||
FileInfoListEnd(FileInfoListEnd),
|
|||
}
|
|||
|
|||
impl RecvServerPacket for RecvPatchPacket {
|
|||
fn from_bytes(data: &[u8]) -> Result<RecvPatchPacket, PacketParseError> {
|
|||
match data[2] {
|
|||
0x02 => Ok(RecvPatchPacket::PatchWelcomeReply(PatchWelcomeReply::from_bytes(data)?)),
|
|||
0x04 => Ok(RecvPatchPacket::LoginReply(LoginReply::from_bytes(data)?)),
|
|||
0x0F => Ok(RecvPatchPacket::FileInfoReply(FileInfoReply::from_bytes(data)?)),
|
|||
0x10 => Ok(RecvPatchPacket::FileInfoListEnd(FileInfoListEnd::from_bytes(data)?)),
|
|||
_ => Err(PacketParseError::WrongPacketForServerType)
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug)]
|
|||
pub enum SendPatchPacket {
|
|||
ChangeDirectory(ChangeDirectory),
|
|||
EndFileSend(EndFileSend),
|
|||
FileInfo(FileInfo),
|
|||
FileSend(FileSend),
|
|||
FilesToPatchMetadata(FilesToPatchMetadata),
|
|||
FinalizePatching(FinalizePatching),
|
|||
Message(Message),
|
|||
PatchEndList(PatchEndList),
|
|||
PatchStartList(PatchStartList),
|
|||
PatchWelcome(PatchWelcome),
|
|||
RequestLogin(RequestLogin),
|
|||
StartFileSend(StartFileSend),
|
|||
UpOneDirectory(UpOneDirectory),
|
|||
}
|
|||
|
|||
impl SendServerPacket for SendPatchPacket {
|
|||
fn as_bytes(&self) -> Vec<u8> {
|
|||
match self {
|
|||
SendPatchPacket::ChangeDirectory(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::EndFileSend(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::FileInfo(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::FileSend(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::FilesToPatchMetadata(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::FinalizePatching(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::Message(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::PatchEndList(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::PatchStartList(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::PatchWelcome(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::RequestLogin(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::StartFileSend(pkt) => pkt.as_bytes(),
|
|||
SendPatchPacket::UpOneDirectory(pkt) => pkt.as_bytes(),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
pub struct PatchServerState {
|
|||
patch_file_tree: PatchFileTree,
|
|||
patch_file_lookup: HashMap<u32, PatchFile>,
|
|||
patch_file_info: Vec<FileInfoReply>,
|
|||
}
|
|||
|
|||
impl PatchServerState {
|
|||
pub fn new(patch_file_tree: PatchFileTree, patch_file_lookup: HashMap<u32, PatchFile>) -> PatchServerState {
|
|||
PatchServerState {
|
|||
patch_file_tree: patch_file_tree,
|
|||
patch_file_lookup: patch_file_lookup,
|
|||
patch_file_info: Vec::new(),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl ServerState for PatchServerState {
|
|||
type SendPacket = SendPatchPacket;
|
|||
type RecvPacket = RecvPatchPacket;
|
|||
type PacketError = PatchError;
|
|||
|
|||
fn on_connect(&mut self, _id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
|
|||
let mut rng = rand::thread_rng();
|
|||
let key_in: u32 = rng.gen();
|
|||
let key_out: u32 = rng.gen();
|
|||
|
|||
vec![OnConnect::Packet(SendPatchPacket::PatchWelcome(PatchWelcome::new(key_out, key_in))),
|
|||
OnConnect::Cipher((Box::new(PSOPCCipher::new(key_in)), Box::new(PSOPCCipher::new(key_out))))
|
|||
]
|
|||
}
|
|||
|
|||
fn handle(&mut self, id: ClientId, pkt: &RecvPatchPacket)
|
|||
-> Result<Box<dyn Iterator<Item = (ClientId, SendPatchPacket)>>, PatchError> {
|
|||
Ok(match pkt {
|
|||
RecvPatchPacket::PatchWelcomeReply(_pkt) => {
|
|||
Box::new(vec![SendPatchPacket::RequestLogin(RequestLogin {})].into_iter().map(move |pkt| (id, pkt)))
|
|||
},
|
|||
RecvPatchPacket::LoginReply(_pkt) => {
|
|||
let mut p = vec![SendPatchPacket::Message(Message::new("hello player".to_string()))];
|
|||
p.append(&mut get_file_list_packets(&self.patch_file_tree));
|
|||
p.push(SendPatchPacket::PatchEndList(PatchEndList {}));
|
|||
Box::new(p.into_iter().map(move |pkt| (id, pkt)))
|
|||
},
|
|||
RecvPatchPacket::FileInfoReply(pkt) => {
|
|||
self.patch_file_info.push(pkt.clone());
|
|||
Box::new(None.into_iter().map(move |pkt| (id, pkt)))
|
|||
},
|
|||
RecvPatchPacket::FileInfoListEnd(_pkt) => {
|
|||
let need_update = self.patch_file_info.iter()
|
|||
.filter(|file_info| does_file_need_updating(file_info, &self.patch_file_lookup))
|
|||
.collect::<Vec<_>>();
|
|||
|
|||
let total_size = need_update.iter().fold(0, |a, file_info| a + file_info.size);
|
|||
let total_files = need_update.len() as u32;
|
|||
|
|||
let p = vec![SendPatchPacket::FilesToPatchMetadata(FilesToPatchMetadata::new(total_size, total_files)),
|
|||
SendPatchPacket::PatchStartList(PatchStartList {})
|
|||
];
|
|||
Box::new(p.into_iter().chain(SendFileIterator::new(&self)).map(move |pkt| (id, pkt)))
|
|||
}
|
|||
})
|
|||
}
|
|||
}
|
|||
|
|||
fn load_patch_dir(basedir: &str, patchbase: &str, file_ids: &mut HashMap<u32, PatchFile>) -> PatchFileTree {
|
|||
let paths = fs::read_dir(basedir).expect("could not read directory");
|
|||
|
|||
let mut files = Vec::new();
|
|||
let mut dirs = Vec::new();
|
|||
for p in paths {
|
|||
let path = p.expect("not a real path").path();
|
|||
if path.is_dir() {
|
|||
let patch_path = path.strip_prefix(basedir).unwrap();
|
|||
dirs.push(load_patch_dir(path.to_str().unwrap(), patch_path.to_str().unwrap(), file_ids));
|
|||
}
|
|||
else {
|
|||
let patch_path = path.strip_prefix(basedir).unwrap();
|
|||
files.push(PatchFileTree::File(patch_path.to_path_buf(), file_ids.len() as u32));
|
|||
let (checksum, size) = get_checksum_and_size(&path).unwrap();
|
|||
file_ids.insert(file_ids.len() as u32, PatchFile {
|
|||
path: path,
|
|||
checksum: checksum,
|
|||
size: size,
|
|||
});
|
|||
}
|
|||
}
|
|||
|
|||
files.append(&mut dirs);
|
|||
|
|||
PatchFileTree::Directory(PathBuf::from(patchbase), files)
|
|||
}
|
|||
|
|||
pub fn generate_patch_tree(basedir: &str) -> (PatchFileTree, HashMap<u32, PatchFile>) {
|
|||
let mut file_ids = HashMap::new();
|
|||
|
|||
let patch_tree = load_patch_dir(basedir, "", &mut file_ids);
|
|||
|
|||
(patch_tree, file_ids)
|
|||
}
|
|||
|
|||
|
|||
fn get_file_list_packets(patch_file_tree: &PatchFileTree) -> Vec<SendPatchPacket> {
|
|||
let mut pkts = Vec::new();
|
|||
|
|||
for item in patch_file_tree.flatten() {
|
|||
match item {
|
|||
PatchTreeIterItem::Directory(path) => {
|
|||
pkts.push(SendPatchPacket::ChangeDirectory(ChangeDirectory::new(path.to_str().unwrap())));
|
|||
},
|
|||
PatchTreeIterItem::File(path, id) => {
|
|||
pkts.push(SendPatchPacket::FileInfo(FileInfo::new(path.to_str().unwrap(), id)));
|
|||
},
|
|||
PatchTreeIterItem::UpDirectory => {
|
|||
pkts.push(SendPatchPacket::UpOneDirectory(UpOneDirectory {}));
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pkts
|
|||
}
|
|||
|
|||
fn get_checksum_and_size(path: &PathBuf) -> Result<(u32, u32), PatchError> {
|
|||
let file = fs::File::open(path)?;
|
|||
let size = file.metadata().unwrap().len();
|
|||
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|||
let mut buf = [0u8; 1024 * 32];
|
|||
let mut reader = io::BufReader::new(file);
|
|||
while let Ok(len) = reader.read(&mut buf) {
|
|||
if len == 0 {
|
|||
break;
|
|||
}
|
|||
crc.write(&buf[0..len]);
|
|||
}
|
|||
|
|||
Ok((crc.sum32(), size as u32))
|
|||
}
|
|||
|
|||
fn does_file_need_updating(file_info: &FileInfoReply, patch_file_lookup: &HashMap<u32, PatchFile>) -> bool {
|
|||
let patch_file = patch_file_lookup.get(&file_info.id).unwrap();
|
|||
patch_file.checksum != file_info.checksum || patch_file.size != file_info.size
|
|||
}
|
|||
|
|||
|
|||
struct SendFileIterator {
|
|||
done: bool,
|
|||
file_iter: Box<dyn Iterator<Item = PatchTreeIterItem>>,
|
|||
file_ids_to_update: HashSet<u32>,
|
|||
patch_file_lookup: HashMap<u32, PatchFile>,
|
|||
current_file: Option<io::BufReader<fs::File>>,
|
|||
chunk_num: u32,
|
|||
}
|
|||
|
|||
impl SendFileIterator {
|
|||
fn new(state: &PatchServerState) -> SendFileIterator {
|
|||
let file_ids_to_update = state.patch_file_info.iter()
|
|||
.filter(|file_info| does_file_need_updating(file_info, &state.patch_file_lookup))
|
|||
.map(|k| k.id)
|
|||
.collect::<HashSet<_>>();
|
|||
|
|||
SendFileIterator {
|
|||
done: false,
|
|||
file_ids_to_update: file_ids_to_update,
|
|||
patch_file_lookup: state.patch_file_lookup.clone(),
|
|||
file_iter: Box::new(state.patch_file_tree.flatten().into_iter()),
|
|||
current_file: None,
|
|||
chunk_num: 0,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl Iterator for SendFileIterator {
|
|||
type Item = SendPatchPacket;
|
|||
|
|||
fn next(&mut self) -> Option<Self::Item> {
|
|||
if self.done {
|
|||
return None;
|
|||
}
|
|||
|
|||
match self.current_file {
|
|||
Some(ref mut file) => {
|
|||
let mut buf = [0u8; PATCH_FILE_CHUNK_SIZE as usize];
|
|||
let len = file.read(&mut buf).unwrap();
|
|||
if len == 0 {
|
|||
self.current_file = None;
|
|||
self.chunk_num = 0;
|
|||
Some(SendPatchPacket::EndFileSend(EndFileSend::new()))
|
|||
}
|
|||
else {
|
|||
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|||
crc.write(&buf[0..len]);
|
|||
let pkt = SendPatchPacket::FileSend(FileSend {
|
|||
chunk_num: self.chunk_num,
|
|||
checksum: crc.sum32(),
|
|||
chunk_size: len as u32,
|
|||
buffer: buf,
|
|||
});
|
|||
self.chunk_num += 1;
|
|||
Some(pkt)
|
|||
}
|
|||
},
|
|||
None => {
|
|||
match self.file_iter.next() {
|
|||
Some(next_file) => {
|
|||
match next_file {
|
|||
PatchTreeIterItem::Directory(path) => {
|
|||
Some(SendPatchPacket::ChangeDirectory(ChangeDirectory::new(path.to_str().unwrap())))
|
|||
},
|
|||
PatchTreeIterItem::File(path, id) => {
|
|||
if self.file_ids_to_update.contains(&id) {
|
|||
let patch_file = self.patch_file_lookup.get(&id).unwrap();
|
|||
let file = fs::File::open(&patch_file.path).unwrap();
|
|||
let size = file.metadata().unwrap().len();
|
|||
self.current_file = Some(io::BufReader::new(file));
|
|||
Some(SendPatchPacket::StartFileSend(StartFileSend::new(path.to_str().unwrap(), size as u32, id)))
|
|||
}
|
|||
else {
|
|||
self.next()
|
|||
}
|
|||
},
|
|||
PatchTreeIterItem::UpDirectory => {
|
|||
Some(SendPatchPacket::UpOneDirectory(UpOneDirectory {}))
|
|||
},
|
|||
}
|
|||
},
|
|||
None => {
|
|||
self.current_file = None;
|
|||
self.done = true;
|
|||
Some(SendPatchPacket::FinalizePatching(FinalizePatching {}))
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue