OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Implement new pfSecurePreloader 

- Fetches a "SecurePreloader" manifest from the FileSrv, allowing gzipped
  python packages
- Save data to the disk for future game launches. We only update if we
  detect what we loaded into memory doesn't match what the server has.
- Falls back to downloading Python\*.pak and SDL\*.pak from the AuthSrv if
  the "SecurePreloader" manifest is not found.
Adam Johnson 13 years ago
parent
e28993aab5
commit
d7fa8cb613
3 changed files with 337 additions and 582 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      Sources/Plasma/Apps/plClient/plClient.cpp
  2. 787
      Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.cpp
  3. 93
      Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.h

9
Sources/Plasma/Apps/plClient/plClient.cpp
Unescape View File

@ -317,10 +317,9 @@ hsBool plClient::Shutdown()
plAgeLoader::SetInstance(nil); plAgeLoader::SetInstance(nil);
} }
if (pfSecurePreloader::IsInstanced()) if (pfSecurePreloader::GetInstance())
{ {
pfSecurePreloader::GetInstance()->Shutdown(); pfSecurePreloader::GetInstance()->Shutdown(); // will unregister itself
// pfSecurePreloader handles its own fixed key unregistration
} }
if (fInputManager) if (fInputManager)
@ -2517,6 +2516,8 @@ void plClient::ICompleteInit () {
void plClient::IHandlePreloaderMsg (plPreloaderMsg * msg) { void plClient::IHandlePreloaderMsg (plPreloaderMsg * msg) {
plgDispatch::Dispatch()->UnRegisterForExactType(plPreloaderMsg::Index(), GetKey()); plgDispatch::Dispatch()->UnRegisterForExactType(plPreloaderMsg::Index(), GetKey());
if (pfSecurePreloader* sp = pfSecurePreloader::GetInstance())
sp->Shutdown();
if (!msg->fSuccess) { if (!msg->fSuccess) {
char str[1024]; char str[1024];
@ -2555,7 +2556,5 @@ void plClient::IHandleNetCommAuthMsg (plNetCommAuthMsg * msg) {
plgDispatch::Dispatch()->RegisterForExactType(plPreloaderMsg::Index(), GetKey()); plgDispatch::Dispatch()->RegisterForExactType(plPreloaderMsg::Index(), GetKey());
// Precache our secure files // Precache our secure files
pfSecurePreloader::GetInstance()->RequestFileGroup(L"Python", L"pak");
pfSecurePreloader::GetInstance()->RequestFileGroup(L"SDL", L"sdl");
pfSecurePreloader::GetInstance()->Start(); pfSecurePreloader::GetInstance()->Start();
} }

787
Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.cpp
Unescape View File

@ -39,608 +39,401 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
Mead, WA 99021 Mead, WA 99021
*==LICENSE==*/ *==LICENSE==*/
#include "hsSTLStream.h"
#include "hsResMgr.h" #include "pfSecurePreloader.h"
#include "hsStream.h"
#include "plgDispatch.h" #include "plgDispatch.h"
#include "pnUtils/pnUtils.h" #include "plCompression/plZlibStream.h"
#include "pnNetBase/pnNetBase.h" #include "plEncryption/plChecksum.h"
#include "pnAsyncCore/pnAsyncCore.h"
#include "pnNetCli/pnNetCli.h"
#include "plNetGameLib/plNetGameLib.h"
#include "plFile/plFileUtils.h" #include "plFile/plFileUtils.h"
#include "plFile/plSecureStream.h"
#include "plFile/plStreamSource.h" #include "plFile/plStreamSource.h"
#include "plNetCommon/plNetCommon.h"
#include "plProgressMgr/plProgressMgr.h"
#include "plMessage/plPreloaderMsg.h"
#include "plMessage/plNetCommMsgs.h" #include "plMessage/plNetCommMsgs.h"
#include "pfSecurePreloader.h" #include "plMessage/plPreloaderMsg.h"
#include "plProgressMgr/plProgressMgr.h"
#include "plNetClientComm/plNetClientComm.h"
extern hsBool gDataServerLocal; extern hsBool gDataServerLocal;
pfSecurePreloader* pfSecurePreloader::fInstance = nil;
/////////////////////////////////////////////////////////////////////
// Max number of concurrent file downloads typedef std::pair<const wchar_t*, const wchar_t*> WcharPair;
static const unsigned kMaxConcurrency = 1;
pfSecurePreloader * pfSecurePreloader::fInstance; struct AuthRequestParams
{
pfSecurePreloader* fThis;
std::queue<WcharPair> fFileGroups;
/////////////////////////////////////////////////////////////////////////////// AuthRequestParams(pfSecurePreloader* parent)
// Callback routines for the network code : fThis(parent) { }
};
// Called when a file's info is retrieved from the server /////////////////////////////////////////////////////////////////////
static void DefaultFileListRequestCallback(ENetError result, void* param, const NetCliAuthFileInfo infoArr[], unsigned infoCount)
{
bool success = !IS_NET_ERROR(result);
std::vector<std::wstring> filenames; void ProcAuthDownloadParams(AuthRequestParams* params);
std::vector<UInt32> sizes;
if (success) void GotAuthSrvManifest(
ENetError result,
void* param,
const NetCliAuthFileInfo infoArr[],
UInt32 infoCount
) {
AuthRequestParams* arp = (AuthRequestParams*)param;
if (IS_NET_ERROR(result))
{ {
filenames.reserve(infoCount); FATAL("Failed to get AuthSrv manifest!");
sizes.reserve(infoCount); arp->fThis->Terminate();
for (unsigned curFile = 0; curFile < infoCount; curFile++) delete arp;
} else {
arp->fThis->PreloadManifest(infoArr, infoCount);
ProcAuthDownloadParams(arp);
}
}
void GotFileSrvManifest(
ENetError result,
void* param,
const wchar_t group[],
const NetCliFileManifestEntry manifest[],
UInt32 entryCount
) {
pfSecurePreloader* sp = (pfSecurePreloader*)param;
if (result == kNetErrFileNotFound)
{ {
filenames.push_back(infoArr[curFile].filename); AuthRequestParams* params = new AuthRequestParams(sp);
sizes.push_back(infoArr[curFile].filesize); params->fFileGroups.push(WcharPair(L"Python", L"pak"));
params->fFileGroups.push(WcharPair(L"SDL", L"sdl"));
ProcAuthDownloadParams(params);
return;
} else if (!entryCount) {
FATAL("SecurePreloader manifest empty!");
sp->Terminate();
return;
} }
sp->PreloadManifest(manifest, entryCount);
}
void FileDownloaded(
ENetError result,
void* param,
const wchar_t filename[],
hsStream* writer
) {
pfSecurePreloader* sp = (pfSecurePreloader*)param;
if (IS_NET_ERROR(result))
{
FATAL("SecurePreloader download failed");
sp->Terminate();
} else {
sp->FilePreloaded(filename, writer);
} }
((pfSecurePreloader*)param)->RequestFinished(filenames, sizes, success);
} }
// Called when a file download is either finished, or failed void ProcAuthDownloadParams(AuthRequestParams* params)
static void DefaultFileRequestCallback(ENetError result, void* param, const wchar filename[], hsStream* stream)
{ {
// Retry download unless shutting down or file not found // Request the "manifests" until there are none left, then download the files
switch (result) { if (params->fFileGroups.empty())
case kNetSuccess: {
((pfSecurePreloader*)param)->FinishedDownload(filename, true); params->fThis->PreloadNextFile();
break; delete params;
} else {
case kNetErrFileNotFound: WcharPair wp = params->fFileGroups.front();
case kNetErrRemoteShutdown: params->fFileGroups.pop();
((pfSecurePreloader*)param)->FinishedDownload(filename, false); NetCliAuthFileListRequest(wp.first, wp.second, GotAuthSrvManifest, params);
break;
default:
stream->Rewind();
NetCliAuthFileRequest(
filename,
stream,
&DefaultFileRequestCallback,
param
);
break;
} }
} }
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////// class pfSecurePreloaderStream : public plZlibStream
// Our custom stream for writing directly to disk securely, and updating the
// progress bar. Does NOT support reading (cause it doesn't need to)
class Direct2DiskStream : public hsUNIXStream
{ {
protected: plOperationProgress* fProgress;
wchar * fWriteFileName; bool fIsZipped;
pfSecurePreloader* fPreloader;
public: public:
Direct2DiskStream(pfSecurePreloader* preloader);
~Direct2DiskStream();
virtual hsBool Open(const char* name, const char* mode = "wb");
virtual hsBool Open(const wchar* name, const wchar* mode = L"wb");
virtual hsBool Close();
virtual UInt32 Read(UInt32 byteCount, void* buffer);
virtual UInt32 Write(UInt32 byteCount, const void* buffer);
};
pfSecurePreloaderStream(plOperationProgress* prog, bool zipped)
: fProgress(prog), fIsZipped(zipped), plZlibStream()
{
fOutput = new hsRAMStream;
}
Direct2DiskStream::Direct2DiskStream(pfSecurePreloader* preloader) : ~pfSecurePreloaderStream()
fWriteFileName(nil), {
fPreloader(preloader) delete fOutput;
{} fOutput = nil;
plZlibStream::Close();
}
Direct2DiskStream::~Direct2DiskStream() hsBool AtEnd() { return fOutput->AtEnd(); }
{ UInt32 GetEOF() { return fOutput->GetEOF(); }
Close(); UInt32 GetPosition() const { return fOutput->GetPosition(); }
} UInt32 GetSizeLeft() const { return fOutput->GetSizeLeft(); }
UInt32 Read(UInt32 count, void* buf) { return fOutput->Read(count, buf); }
void Rewind() { fOutput->Rewind(); }
void SetPosition(UInt32 pos) { fOutput->SetPosition(pos); }
void Skip(UInt32 deltaByteCount) { fOutput->Skip(deltaByteCount); }
hsBool Direct2DiskStream::Open(const char* name, const char* mode) UInt32 Write(UInt32 count, const void* buf)
{ {
wchar* wName = hsStringToWString(name); if (fProgress)
wchar* wMode = hsStringToWString(mode); fProgress->Increment((hsScalar)count);
hsBool ret = Open(wName, wMode); if (fIsZipped)
delete [] wName; return plZlibStream::Write(count, buf);
delete [] wMode; else
return ret; return fOutput->Write(count, buf);
} }
};
/////////////////////////////////////////////////////////////////////
pfSecurePreloader::pfSecurePreloader()
: fProgress(nil), fLegacyMode(false)
{ }
hsBool Direct2DiskStream::Open(const wchar* name, const wchar* mode) pfSecurePreloader::~pfSecurePreloader()
{ {
if (0 != wcscmp(mode, L"wb")) { while (fDownloadEntries.size())
hsAssert(0, "Unsupported open mode"); {
return false; free((void*)fDownloadEntries.front());
fDownloadEntries.pop();
} }
fWriteFileName = TRACKED_NEW(wchar[wcslen(name) + 1]); while (fManifestEntries.size())
wcscpy(fWriteFileName, name); {
free((void*)fManifestEntries.front());
// LogMsg(kLogPerf, L"Opening disk file %S", fWriteFileName); fManifestEntries.pop();
return hsUNIXStream::Open(name, mode); }
} }
hsBool Direct2DiskStream::Close() hsRAMStream* pfSecurePreloader::LoadToMemory(const wchar_t* file) const
{ {
delete [] fWriteFileName; if (!plFileUtils::FileExists(file))
fWriteFileName = nil; return nil;
return hsUNIXStream::Close();
hsUNIXStream s;
hsRAMStream* ram = new hsRAMStream;
s.Open(file);
UInt32 loadLen = 1024 * 1024;
UInt8* buf = new UInt8[loadLen];
while (UInt32 read = s.Read(loadLen, buf))
ram->Write(read, buf);
delete[] buf;
s.Close();
ram->Rewind();
return ram;
} }
UInt32 Direct2DiskStream::Read(UInt32 bytes, void* buffer) void pfSecurePreloader::SaveFile(hsStream* file, const wchar_t* name) const
{ {
hsAssert(0, "not implemented"); hsUNIXStream s;
return 0; // we don't read s.Open(name, L"wb");
UInt32 pos = file->GetPosition();
file->Rewind();
UInt32 loadLen = 1024 * 1024;
UInt8* buf = new UInt8[loadLen];
while (UInt32 read = file->Read(loadLen, buf))
s.Write(read, buf);
file->SetPosition(pos);
s.Close();
delete[] buf;
} }
UInt32 Direct2DiskStream::Write(UInt32 bytes, const void* buffer) bool pfSecurePreloader::IsZipped(const wchar_t* filename) const
{ {
// LogMsg(kLogPerf, L"Writing %u bytes to disk file %S", bytes, fWriteFileName); return wcscmp(plFileUtils::GetFileExt(filename), L"gz") == 0;
fPreloader->UpdateProgressBar(bytes);
return hsUNIXStream::Write(bytes, buffer);
} }
void pfSecurePreloader::PreloadNextFile()
///////////////////////////////////////////////////////////////////////////////
// secure preloader class implementation
// closes and deletes all streams
void pfSecurePreloader::ICleanupStreams()
{ {
if (fD2DStreams.size() > 0) if (fManifestEntries.empty())
{ {
std::map<std::wstring, hsStream*>::iterator curStream; Finish();
for (curStream = fD2DStreams.begin(); curStream != fD2DStreams.end(); curStream++) return;
{
curStream->second->Close();
delete curStream->second;
curStream->second = nil;
}
fD2DStreams.clear();
} }
}
// queues a single file to be preloaded (does nothing if already preloaded) const wchar_t* filename = fDownloadEntries.front();
void pfSecurePreloader::RequestSingleFile(std::wstring filename) hsStream* s = new pfSecurePreloaderStream(fProgress, IsZipped(filename));
{
fileRequest request;
ZERO(request);
request.fType = fileRequest::kSingleFile;
request.fPath = filename;
request.fExt = L"";
fRequests.push_back(request); // Thankfully, both callbacks have the same arguments
if (fLegacyMode)
NetCliAuthFileRequest(filename, s, FileDownloaded, this);
else
NetCliFileDownloadRequest(filename, s, FileDownloaded, this);
} }
// queues a group of files to be preloaded (does nothing if already preloaded) void pfSecurePreloader::Init()
void pfSecurePreloader::RequestFileGroup(std::wstring dir, std::wstring ext)
{ {
fileRequest request; RegisterAs(kSecurePreloader_KEY);
ZERO(request); // TODO: If we're going to support reconnects, then let's do it right.
request.fType = fileRequest::kFileList; // Later...
request.fPath = dir; //plgDispatch::Dispatch()->RegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey());
request.fExt = ext;
fRequests.push_back(request);
} }
// preloads all requested files from the server (does nothing if already preloaded)
void pfSecurePreloader::Start() void pfSecurePreloader::Start()
{ {
if (gDataServerLocal) { #ifndef PLASMA_EXTERNAL_RELEASE
// using local data, don't do anything // Using local data? Move along, move along...
plPreloaderMsg * msg = TRACKED_NEW plPreloaderMsg(); if (gDataServerLocal)
msg->fSuccess = true; {
msg->Send(); Finish();
return; return;
} }
#endif
NetCliAuthGetEncryptionKey(fEncryptionKey, 4); // grab the encryption key from the server NetCliAuthGetEncryptionKey(fEncryptionKey, 4);
fNetError = false;
// make sure we are all cleaned up
ICleanupStreams();
fTotalDataReceived = 0;
// update the progress bar for downloading // TODO: Localize
if (!fProgressBar) fProgress = plProgressMgr::GetInstance()->RegisterOperation(0.0f, "Checking for Updates", plProgressMgr::kUpdateText, false, true);
fProgressBar = plProgressMgr::GetInstance()->RegisterOperation((hsScalar)(fRequests.size()), "Getting file info...", plProgressMgr::kUpdateText, false, true);
for (unsigned curRequest = 0; curRequest < fRequests.size(); curRequest++) // Now, we need to fetch the "SecurePreloader" manifest from the file server, which will contain the python and SDL files.
{ // We're basically reimplementing plResPatcher here, except preferring to keep everything in memory, then flush to disk
fNumInfoRequestsRemaining++; // increment the counter // when we're done. If this fails, then we shall download everything from the AuthSrv like in the old days.
if (fRequests[curRequest].fType == fileRequest::kSingleFile) NetCliFileManifestRequest(GotFileSrvManifest, this, L"SecurePreloader");
{
#ifndef PLASMA_EXTERNAL_RELEASE
// in internal releases, we can use on-disk files if they exist
if (plFileUtils::FileExists(fRequests[curRequest].fPath.c_str()))
{
fileInfo info;
info.fOriginalNameAndPath = fRequests[curRequest].fPath;
info.fSizeInBytes = plFileUtils::GetFileSize(info.fOriginalNameAndPath.c_str());
info.fDownloading = false;
info.fDownloaded = false;
info.fLocal = true;
// generate garbled name
wchar_t pathBuffer[MAX_PATH + 1];
wchar_t filename[arrsize(pathBuffer)];
GetTempPathW(arrsize(pathBuffer), pathBuffer);
GetTempFileNameW(pathBuffer, L"CYN", 0, filename);
info.fGarbledNameAndPath = filename;
fTotalDataDownload += info.fSizeInBytes;
fFileInfoMap[info.fOriginalNameAndPath] = info;
}
// internal client will still request it, even if it exists locally,
// so that things get updated properly
#endif // PLASMA_EXTERNAL_RELEASE
NetCliAuthFileListRequest(
fRequests[curRequest].fPath.c_str(),
nil,
&DefaultFileListRequestCallback,
(void*)this
);
}
else
{
#ifndef PLASMA_EXTERNAL_RELEASE
// in internal releases, we can use on-disk files if they exist
// Build the search string as "dir\\*.ext"
wchar searchStr[MAX_PATH];
PathAddFilename(searchStr, fRequests[curRequest].fPath.c_str(), L"*", arrsize(searchStr));
PathSetExtension(searchStr, searchStr, fRequests[curRequest].fExt.c_str(), arrsize(searchStr));
ARRAY(PathFind) paths;
PathFindFiles(&paths, searchStr, kPathFlagFile); // find all files that match
// convert it to our little file info array
PathFind* curFile = paths.Ptr();
PathFind* lastFile = paths.Term();
while (curFile != lastFile) {
fileInfo info;
info.fOriginalNameAndPath = curFile->name;
info.fSizeInBytes = (UInt32)curFile->fileLength;
info.fDownloading = false;
info.fDownloaded = false;
info.fLocal = true;
// generate garbled name
wchar_t pathBuffer[MAX_PATH + 1];
wchar_t filename[arrsize(pathBuffer)];
GetTempPathW(arrsize(pathBuffer), pathBuffer);
GetTempFileNameW(pathBuffer, L"CYN", 0, filename);
info.fGarbledNameAndPath = filename;
fTotalDataDownload += info.fSizeInBytes;
fFileInfoMap[info.fOriginalNameAndPath] = info;
curFile++;
}
#endif // PLASMA_EXTERNAL_RELEASE
NetCliAuthFileListRequest(
fRequests[curRequest].fPath.c_str(),
fRequests[curRequest].fExt.c_str(),
&DefaultFileListRequestCallback,
(void*)this
);
}
}
} }
// closes all file pointers and cleans up after itself void pfSecurePreloader::Terminate()
void pfSecurePreloader::Cleanup()
{ {
ICleanupStreams(); FATAL("pfSecurePreloader failure");
fRequests.clear();
fFileInfoMap.clear();
fNumInfoRequestsRemaining = 0; plPreloaderMsg* msg = new plPreloaderMsg;
fTotalDataDownload = 0; msg->fSuccess = false;
fTotalDataReceived = 0; plgDispatch::Dispatch()->MsgSend(msg);
DEL(fProgressBar);
fProgressBar = nil;
} }
//============================================================================ void pfSecurePreloader::Finish()
void pfSecurePreloader::RequestFinished(const std::vector<std::wstring> & filenames, const std::vector<UInt32> & sizes, bool succeeded)
{ {
fNetError |= !succeeded; plPreloaderMsg* msg = new plPreloaderMsg;
msg->fSuccess = true;
plgDispatch::Dispatch()->MsgSend(msg);
}
if (succeeded) void pfSecurePreloader::Shutdown()
{ {
unsigned count = 0; SetInstance(nil);
for (int curFile = 0; curFile < filenames.size(); curFile++) if (fProgress)
{ {
if (fFileInfoMap.find(filenames[curFile]) != fFileInfoMap.end()) delete fProgress;
continue; // if it is a duplicate, ignore it (the duplicate is probably one we found locally) fProgress = nil;
fileInfo info;
info.fOriginalNameAndPath = filenames[curFile];
info.fSizeInBytes = sizes[curFile];
info.fDownloading = false;
info.fDownloaded = false;
info.fLocal = false; // if we get here, it was retrieved remotely
// generate garbled name
wchar_t pathBuffer[MAX_PATH + 1];
wchar_t filename[arrsize(pathBuffer)];
GetTempPathW(arrsize(pathBuffer), pathBuffer);
GetTempFileNameW(pathBuffer, L"CYN", 0, filename);
info.fGarbledNameAndPath = filename;
fTotalDataDownload += info.fSizeInBytes;
fFileInfoMap[info.fOriginalNameAndPath] = info;
++count;
} }
LogMsg(kLogPerf, "Added %u files to secure download queue", count);
}
if (fProgressBar)
fProgressBar->Increment(1.f);
--fNumInfoRequestsRemaining; // even if we fail, decrement the counter
if (succeeded) { // Takes care of UnReffing us
DEL(fProgressBar); UnRegisterAs(kSecurePreloader_KEY);
fProgressBar = plProgressMgr::GetInstance()->RegisterOperation((hsScalar)(fTotalDataDownload), "Downloading...", plProgressMgr::kUpdateText, false, true);
// Issue some file download requests (up to kMaxConcurrency)
IIssueDownloadRequests();
}
else {
IPreloadComplete();
}
} }
//============================================================================ void pfSecurePreloader::PreloadManifest(const NetCliAuthFileInfo manifestEntries[], UInt32 entryCount)
void pfSecurePreloader::IIssueDownloadRequests () { {
UInt32 totalBytes = 0;
if (fProgress)
totalBytes = (UInt32)fProgress->GetMax();
fLegacyMode = true;
std::map<std::wstring, fileInfo>::iterator curFile; for (UInt32 i = 0; i < entryCount; ++i)
for (curFile = fFileInfoMap.begin(); curFile != fFileInfoMap.end(); curFile++)
{ {
// Skip files already downloaded or currently downloading const NetCliAuthFileInfo mfs = manifestEntries[i];
if (curFile->second.fDownloaded || curFile->second.fDownloading) fDownloadEntries.push(wcsdup(mfs.filename));
continue; if (IsZipped(mfs.filename))
std::wstring filename = curFile->second.fOriginalNameAndPath;
#ifndef PLASMA_EXTERNAL_RELEASE
// in internal releases, we can use on-disk files if they exist
if (plFileUtils::FileExists(filename.c_str()))
{ {
// don't bother streaming, just make the secure stream using the local file wchar_t* name = wcsdup(mfs.filename);
plFileUtils::StripExt(name);
// a local key overrides the server-downloaded key fManifestEntries.push(name);
UInt32 localKey[4];
bool hasLocalKey = plFileUtils::GetSecureEncryptionKey(filename.c_str(), localKey, arrsize(localKey));
hsStream* stream = nil;
if (hasLocalKey)
stream = plSecureStream::OpenSecureFile(filename.c_str(), 0, localKey);
else
stream = plSecureStream::OpenSecureFile(filename.c_str(), 0, fEncryptionKey);
// add it to the stream source } else
bool added = plStreamSource::GetInstance()->InsertFile(filename.c_str(), stream); fManifestEntries.push(wcsdup(mfs.filename));
if (!added)
DEL(stream); // wasn't added, so nuke our local copy
// and make sure the vars are set up right totalBytes += mfs.filesize;
curFile->second.fDownloaded = true;
curFile->second.fLocal = true;
} }
else
#endif if (fProgress)
{ {
// Enforce concurrency limit fProgress->SetLength((hsScalar)totalBytes);
if (fNumDownloadRequestsRemaining >= kMaxConcurrency) fProgress->SetTitle("Downloading...");
break;
curFile->second.fDownloading = true;
curFile->second.fDownloaded = false;
curFile->second.fLocal = false;
// create and setup the stream
Direct2DiskStream* fileStream = TRACKED_NEW Direct2DiskStream(this);
fileStream->Open(curFile->second.fGarbledNameAndPath.c_str(), L"wb");
fD2DStreams[filename] = (hsStream*)fileStream;
// request the file from the server
LogMsg(kLogPerf, L"Requesting secure file:%s", filename.c_str());
++fNumDownloadRequestsRemaining;
NetCliAuthFileRequest(
filename.c_str(),
(hsStream*)fileStream,
&DefaultFileRequestCallback,
this
);
}
} }
if (!fNumDownloadRequestsRemaining)
IPreloadComplete();
}
void pfSecurePreloader::UpdateProgressBar(UInt32 bytesReceived)
{
fTotalDataReceived += bytesReceived;
if (fTotalDataReceived > fTotalDataDownload)
fTotalDataReceived = fTotalDataDownload; // shouldn't happen... but just in case
if (fProgressBar)
fProgressBar->Increment((hsScalar)bytesReceived);
} }
void pfSecurePreloader::FinishedDownload(std::wstring filename, bool succeeded) void pfSecurePreloader::PreloadManifest(const NetCliFileManifestEntry manifestEntries[], UInt32 entryCount)
{ {
for (;;) UInt32 totalBytes = 0;
for (UInt32 i = 0; i < entryCount; ++i)
{ {
if (fFileInfoMap.find(filename) == fFileInfoMap.end()) const NetCliFileManifestEntry mfs = manifestEntries[i];
{ bool fetchMe = true;
// file doesn't exist... abort hsRAMStream* s = nil;
succeeded = false;
break;
}
fFileInfoMap[filename].fDownloading = false;
// close and delete the writer stream (even if we failed)
fD2DStreams[filename]->Close();
delete fD2DStreams[filename];
fD2DStreams.erase(fD2DStreams.find(filename));
if (succeeded) if (plFileUtils::FileExists(mfs.clientName))
{ {
// open a secure stream to that file s = LoadToMemory(mfs.clientName);
hsStream* stream = plSecureStream::OpenSecureFile( if (s)
fFileInfoMap[filename].fGarbledNameAndPath.c_str(), {
plSecureStream::kRequireEncryption | plSecureStream::kDeleteOnExit, // force delete and encryption // Damn this
fEncryptionKey const char* md5 = hsWStringToString(mfs.md5);
); plMD5Checksum srvHash;
srvHash.SetFromHexString(md5);
bool addedToSource = plStreamSource::GetInstance()->InsertFile(filename.c_str(), stream); delete[] md5;
if (!addedToSource)
DEL(stream); // cleanup if it wasn't added // Now actually copare the hashes
plMD5Checksum lclHash;
fFileInfoMap[filename].fDownloaded = true; lclHash.CalcFromStream(s);
break; fetchMe = (srvHash != lclHash);
} }
// file download failed, clean up after it
// delete the temporary file
if (plFileUtils::FileExists(fFileInfoMap[filename].fGarbledNameAndPath.c_str()))
plFileUtils::RemoveFile(fFileInfoMap[filename].fGarbledNameAndPath.c_str(), true);
// and remove it from the info map
fFileInfoMap.erase(fFileInfoMap.find(filename));
break;
} }
fNetError |= !succeeded; if (fetchMe)
--fNumDownloadRequestsRemaining; {
LogMsg(kLogPerf, L"Received secure file:%s, success:%s", filename.c_str(), succeeded ? L"Yep" : L"Nope"); fManifestEntries.push(wcsdup(mfs.clientName));
fDownloadEntries.push(wcsdup(mfs.downloadName));
if (!succeeded) if (IsZipped(mfs.downloadName))
IPreloadComplete(); totalBytes += mfs.zipSize;
else else
// Issue some file download requests (up to kMaxConcurrency) totalBytes += mfs.fileSize;
IIssueDownloadRequests(); } else {
} plSecureStream* ss = new plSecureStream(s, fEncryptionKey);
plStreamSource::GetInstance()->InsertFile(mfs.clientName, ss);
//============================================================================
void pfSecurePreloader::INotifyAuthReconnected () {
// The secure file download network protocol will now just pick up downloading
// where it left off before the reconnect, so no need to reset in-progress files.
/*
std::map<std::wstring, fileInfo>::iterator curFile;
for (curFile = fFileInfoMap.begin(); curFile != fFileInfoMap.end(); curFile++) {
// Reset files that were currently downloading
if (curFile->second.fDownloading)
curFile->second.fDownloading = false;
} }
if (fNumDownloadRequestsRemaining > 0) { if (s)
delete s;
LogMsg(kLogPerf, L"pfSecurePreloader: Auth reconnected, resetting in-progress file downloads");
// Issue some file download requests (up to kMaxConcurrency)
IIssueDownloadRequests();
}
*/
}
//============================================================================
void pfSecurePreloader::IPreloadComplete () {
DEL(fProgressBar);
fProgressBar = nil;
plPreloaderMsg * msg = TRACKED_NEW plPreloaderMsg();
msg->fSuccess = !fNetError;
msg->Send();
}
//============================================================================
hsBool pfSecurePreloader::MsgReceive (plMessage * msg) {
if (plNetCommAuthConnectedMsg * authMsg = plNetCommAuthConnectedMsg::ConvertNoRef(msg)) {
INotifyAuthReconnected();
return true;
} }
return hsKeyedObject::MsgReceive(msg); if (totalBytes && fProgress)
} {
fProgress->SetLength((hsScalar)totalBytes);
//============================================================================ fProgress->SetTitle("Downloading...");
pfSecurePreloader * pfSecurePreloader::GetInstance () {
if (!fInstance) {
fInstance = NEWZERO(pfSecurePreloader);
fInstance->RegisterAs(kSecurePreloader_KEY);
} }
return fInstance; // This method uses only one manifest, so we're good to go now!
PreloadNextFile();
} }
//============================================================================ void pfSecurePreloader::FilePreloaded(const wchar_t* file, hsStream* stream)
bool pfSecurePreloader::IsInstanced () { {
// Clear out queue
return fInstance != nil; fDownloadEntries.pop();
} const wchar_t* clientName = fManifestEntries.front(); // Stolen by plStreamSource
fManifestEntries.pop();
//============================================================================
void pfSecurePreloader::Init () {
if (!fInitialized) {
fInitialized = true;
plgDispatch::Dispatch()->RegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey());
}
}
//============================================================================
void pfSecurePreloader::Shutdown () {
if (fInitialized) {
fInitialized = false; if (!fLegacyMode) // AuthSrv data caching is useless
plgDispatch::Dispatch()->UnRegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey()); {
plFileUtils::EnsureFilePathExists(clientName);
SaveFile(stream, clientName);
} }
if (fInstance) { plSecureStream* ss = new plSecureStream(stream, fEncryptionKey);
plStreamSource::GetInstance()->InsertFile(clientName, ss);
fInstance->UnRegister(); delete stream; // SecureStream holds its own decrypted buffer
fInstance = nil;
}
}
//============================================================================ // Continue down the warpath
pfSecurePreloader::pfSecurePreloader () { PreloadNextFile();
} }
//============================================================================ pfSecurePreloader* pfSecurePreloader::GetInstance()
pfSecurePreloader::~pfSecurePreloader () { {
if (!fInstance)
Cleanup(); fInstance = new pfSecurePreloader;
return fInstance;
} }

93
Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.h
Unescape View File

@ -42,15 +42,13 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#ifndef __pfSecurePreloader_h__ #ifndef __pfSecurePreloader_h__
#define __pfSecurePreloader_h__ #define __pfSecurePreloader_h__
#include "hsTypes.h" #include "HeadSpin.h"
#include "hsStlUtils.h"
#include "hsCritSect.h"
#include "hsStream.h"
#include "plFile/plSecureStream.h"
#include "pnKeyedObject/hsKeyedObject.h" #include "pnKeyedObject/hsKeyedObject.h"
#include "plNetGameLib/plNetGameLib.h"
#include <queue>
class plOperationProgress; class plOperationProgress;
class hsRAMStream;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// pfSecurePreloader - a class for handling files we want downloaded from the // pfSecurePreloader - a class for handling files we want downloaded from the
@ -60,75 +58,40 @@ class plOperationProgress;
class pfSecurePreloader : public hsKeyedObject class pfSecurePreloader : public hsKeyedObject
{ {
private: private:
static pfSecurePreloader * fInstance;
struct fileRequest
{
enum requestType {kSingleFile, kFileList};
requestType fType;
std::wstring fPath; // filename if kSingleFile, path if kFileList
std::wstring fExt; // blank if kSingleFile, extension if kFileList
};
std::vector<fileRequest> fRequests;
struct fileInfo
{
std::wstring fOriginalNameAndPath; // the human-readable name
std::wstring fGarbledNameAndPath; // the garbled temp name of the file on disk
UInt32 fSizeInBytes; // the total size of the file
bool fDownloading; // is this file currently downloading?
bool fDownloaded; // is this file completely downloaded?
bool fLocal; // is the file a local copy?
};
std::map<std::wstring, fileInfo> fFileInfoMap; // key is human-readable name
std::map<std::wstring, hsStream*> fD2DStreams; // direct-to-disk streams, only used while downloading from the server
UInt32 fNumInfoRequestsRemaining; // the number of file info requests that are still pending
UInt32 fNumDownloadRequestsRemaining; // the number of file download requests that are still pending
UInt32 fTotalDataDownload; // the amount of data we need to download, for progress bar tracking
UInt32 fTotalDataReceived; // the amount of data we have already preloaded, for progress bar tracking
bool fNetError;
bool fInitialized;
UInt32 fEncryptionKey[4]; // encryption key for all the secure files
plOperationProgress* fProgressBar;
void IIssueDownloadRequests (); static pfSecurePreloader* fInstance;
void IPreloadComplete (); std::queue<const wchar_t*> fManifestEntries;
std::queue<const wchar_t*> fDownloadEntries;
plOperationProgress* fProgress;
UInt32 fEncryptionKey[4];
bool fLegacyMode;
void ICleanupStreams(); // closes and deletes all streams hsRAMStream* LoadToMemory(const wchar_t* file) const;
void SaveFile(hsStream* file, const wchar_t* name) const;
void INotifyAuthReconnected (); bool IsZipped(const wchar_t* filename) const;
pfSecurePreloader ();
public: public:
pfSecurePreloader();
~pfSecurePreloader();
CLASSNAME_REGISTER(pfSecurePreloader); CLASSNAME_REGISTER(pfSecurePreloader);
GETINTERFACE_ANY(pfSecurePreloader, hsKeyedObject); GETINTERFACE_ANY(pfSecurePreloader, hsKeyedObject);
~pfSecurePreloader (); void Init();
void Start();
void Init (); void Terminate();
void Shutdown (); void Finish();
void Shutdown();
// Client interface functions
void RequestSingleFile(std::wstring filename); // queues a single file to be preloaded (does nothing if already preloaded)
void RequestFileGroup(std::wstring dir, std::wstring ext); // queues a group of files to be preloaded (does nothing if already preloaded)
void Start(); // sends all queued requests (does nothing if already preloaded)
void Cleanup(); // closes all file pointers and cleans up after itself
// Functions for the network callbacks void PreloadManifest(const NetCliFileManifestEntry manifestEntries[], UInt32 entryCount);
void RequestFinished(const std::vector<std::wstring> & filenames, const std::vector<UInt32> & sizes, bool succeeded); void PreloadManifest(const NetCliAuthFileInfo manifestEntries[], UInt32 entryCount);
void UpdateProgressBar(UInt32 bytesReceived); void PreloadNextFile();
void FinishedDownload(std::wstring filename, bool succeeded); void FilePreloaded(const wchar_t* filename, hsStream* stream);
// Instance handling plOperationProgress* GetProgressBar() { return fProgress; }
static pfSecurePreloader * GetInstance ();
static bool IsInstanced ();
// hsKeyedObject static pfSecurePreloader* GetInstance();
hsBool MsgReceive (plMessage * msg); static void SetInstance(pfSecurePreloader* instance) { fInstance = instance; }
}; };
#endif // __pfSecurePreloader_h__ #endif // __pfSecurePreloader_h__

Write Preview
Loading…
Cancel
Save