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

Merge pull request #115 from Hoikas/securepreloader 

pfSecurePreloader refactor
Branan Purvine-Riley 13 years ago
parent
d420ac6da7 d7fa8cb613
commit
0e11edf24e
11 changed files with 439 additions and 598 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. 3
      Sources/Plasma/CoreLib/hsStream.cpp
  3. 767
      Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.cpp
  4. 85
      Sources/Plasma/FeatureLib/pfSecurePreloader/pfSecurePreloader.h
  5. 22
      Sources/Plasma/PubUtilLib/plEncryption/plChecksum.cpp
  6. 4
      Sources/Plasma/PubUtilLib/plEncryption/plChecksum.h
  7. 7
      Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp
  8. 1
      Sources/Plasma/PubUtilLib/plFile/plFileUtils.h
  9. 57
      Sources/Plasma/PubUtilLib/plFile/plSecureStream.cpp
  10. 3
      Sources/Plasma/PubUtilLib/plFile/plSecureStream.h
  11. 7
      Sources/Plasma/PubUtilLib/plFile/plStreamSource.cpp

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();
} }

3
Sources/Plasma/CoreLib/hsStream.cpp
Unescape View File

@ -1054,10 +1054,7 @@ hsBool hsRAMStream::AtEnd()
UInt32 hsRAMStream::Read(UInt32 byteCount, void * buffer) UInt32 hsRAMStream::Read(UInt32 byteCount, void * buffer)
{ {
if (fBytesRead + byteCount > fAppender.Count() * fAppender.ElemSize()) if (fBytesRead + byteCount > fAppender.Count() * fAppender.ElemSize())
{
hsThrow("Attempting to read past end of stream");
byteCount = (fAppender.Count() * fAppender.ElemSize()) - fBytesRead; byteCount = (fAppender.Count() * fAppender.ElemSize()) - fBytesRead;
}
fBytesRead += byteCount; fBytesRead += byteCount;
fPosition += byteCount; fPosition += byteCount;

767
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)
{ void ProcAuthDownloadParams(AuthRequestParams* params);
bool success = !IS_NET_ERROR(result);
void GotAuthSrvManifest(
ENetError result,
void* param,
const NetCliAuthFileInfo infoArr[],
UInt32 infoCount
) {
AuthRequestParams* arp = (AuthRequestParams*)param;
if (IS_NET_ERROR(result))
{
FATAL("Failed to get AuthSrv manifest!");
arp->fThis->Terminate();
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)
{
AuthRequestParams* params = new AuthRequestParams(sp);
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;
}
std::vector<std::wstring> filenames; sp->PreloadManifest(manifest, entryCount);
std::vector<UInt32> sizes;
if (success)
{
filenames.reserve(infoCount);
sizes.reserve(infoCount);
for (unsigned curFile = 0; curFile < infoCount; curFile++)
{
filenames.push_back(infoArr[curFile].filename);
sizes.push_back(infoArr[curFile].filesize);
} }
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);
};
Direct2DiskStream::Direct2DiskStream(pfSecurePreloader* preloader) :
fWriteFileName(nil),
fPreloader(preloader)
{}
Direct2DiskStream::~Direct2DiskStream() pfSecurePreloaderStream(plOperationProgress* prog, bool zipped)
: fProgress(prog), fIsZipped(zipped), plZlibStream()
{ {
Close(); fOutput = new hsRAMStream;
} }
hsBool Direct2DiskStream::Open(const char* name, const char* mode) ~pfSecurePreloaderStream()
{ {
wchar* wName = hsStringToWString(name); delete fOutput;
wchar* wMode = hsStringToWString(mode); fOutput = nil;
hsBool ret = Open(wName, wMode); plZlibStream::Close();
delete [] wName;
delete [] wMode;
return ret;
} }
hsBool Direct2DiskStream::Open(const wchar* name, const wchar* mode) hsBool AtEnd() { return fOutput->AtEnd(); }
UInt32 GetEOF() { return fOutput->GetEOF(); }
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); }
UInt32 Write(UInt32 count, const void* buf)
{ {
if (0 != wcscmp(mode, L"wb")) { if (fProgress)
hsAssert(0, "Unsupported open mode"); fProgress->Increment((hsScalar)count);
return false; if (fIsZipped)
return plZlibStream::Write(count, buf);
else
return fOutput->Write(count, buf);
} }
};
fWriteFileName = TRACKED_NEW(wchar[wcslen(name) + 1]); /////////////////////////////////////////////////////////////////////
wcscpy(fWriteFileName, name);
// LogMsg(kLogPerf, L"Opening disk file %S", fWriteFileName); pfSecurePreloader::pfSecurePreloader()
return hsUNIXStream::Open(name, mode); : fProgress(nil), fLegacyMode(false)
} { }
hsBool Direct2DiskStream::Close() pfSecurePreloader::~pfSecurePreloader()
{
while (fDownloadEntries.size())
{ {
delete [] fWriteFileName; free((void*)fDownloadEntries.front());
fWriteFileName = nil; fDownloadEntries.pop();
return hsUNIXStream::Close();
} }
UInt32 Direct2DiskStream::Read(UInt32 bytes, void* buffer) while (fManifestEntries.size())
{ {
hsAssert(0, "not implemented"); free((void*)fManifestEntries.front());
return 0; // we don't read fManifestEntries.pop();
}
} }
UInt32 Direct2DiskStream::Write(UInt32 bytes, const void* buffer) hsRAMStream* pfSecurePreloader::LoadToMemory(const wchar_t* file) const
{ {
// LogMsg(kLogPerf, L"Writing %u bytes to disk file %S", bytes, fWriteFileName); if (!plFileUtils::FileExists(file))
fPreloader->UpdateProgressBar(bytes); return nil;
return hsUNIXStream::Write(bytes, buffer);
}
hsUNIXStream s;
hsRAMStream* ram = new hsRAMStream;
s.Open(file);
/////////////////////////////////////////////////////////////////////////////// UInt32 loadLen = 1024 * 1024;
// secure preloader class implementation UInt8* buf = new UInt8[loadLen];
while (UInt32 read = s.Read(loadLen, buf))
ram->Write(read, buf);
delete[] buf;
// closes and deletes all streams s.Close();
void pfSecurePreloader::ICleanupStreams() ram->Rewind();
{ return ram;
if (fD2DStreams.size() > 0)
{
std::map<std::wstring, hsStream*>::iterator curStream;
for (curStream = fD2DStreams.begin(); curStream != fD2DStreams.end(); curStream++)
{
curStream->second->Close();
delete curStream->second;
curStream->second = nil;
}
fD2DStreams.clear();
}
} }
// queues a single file to be preloaded (does nothing if already preloaded) void pfSecurePreloader::SaveFile(hsStream* file, const wchar_t* name) const
void pfSecurePreloader::RequestSingleFile(std::wstring filename)
{ {
fileRequest request; hsUNIXStream s;
ZERO(request); s.Open(name, L"wb");
request.fType = fileRequest::kSingleFile; UInt32 pos = file->GetPosition();
request.fPath = filename; file->Rewind();
request.fExt = L"";
fRequests.push_back(request); 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;
} }
// queues a group of files to be preloaded (does nothing if already preloaded) bool pfSecurePreloader::IsZipped(const wchar_t* filename) const
void pfSecurePreloader::RequestFileGroup(std::wstring dir, std::wstring ext)
{ {
fileRequest request; return wcscmp(plFileUtils::GetFileExt(filename), L"gz") == 0;
ZERO(request);
request.fType = fileRequest::kFileList;
request.fPath = dir;
request.fExt = ext;
fRequests.push_back(request);
} }
// preloads all requested files from the server (does nothing if already preloaded) void pfSecurePreloader::PreloadNextFile()
void pfSecurePreloader::Start()
{ {
if (gDataServerLocal) { if (fManifestEntries.empty())
// using local data, don't do anything {
plPreloaderMsg * msg = TRACKED_NEW plPreloaderMsg(); Finish();
msg->fSuccess = true;
msg->Send();
return; return;
} }
NetCliAuthGetEncryptionKey(fEncryptionKey, 4); // grab the encryption key from the server const wchar_t* filename = fDownloadEntries.front();
hsStream* s = new pfSecurePreloaderStream(fProgress, IsZipped(filename));
fNetError = false; // Thankfully, both callbacks have the same arguments
if (fLegacyMode)
// make sure we are all cleaned up NetCliAuthFileRequest(filename, s, FileDownloaded, this);
ICleanupStreams(); else
fTotalDataReceived = 0; NetCliFileDownloadRequest(filename, s, FileDownloaded, this);
}
// update the progress bar for downloading
if (!fProgressBar)
fProgressBar = plProgressMgr::GetInstance()->RegisterOperation((hsScalar)(fRequests.size()), "Getting file info...", plProgressMgr::kUpdateText, false, true);
for (unsigned curRequest = 0; curRequest < fRequests.size(); curRequest++) void pfSecurePreloader::Init()
{
fNumInfoRequestsRemaining++; // increment the counter
if (fRequests[curRequest].fType == fileRequest::kSingleFile)
{ {
#ifndef PLASMA_EXTERNAL_RELEASE RegisterAs(kSecurePreloader_KEY);
// in internal releases, we can use on-disk files if they exist // TODO: If we're going to support reconnects, then let's do it right.
if (plFileUtils::FileExists(fRequests[curRequest].fPath.c_str())) // Later...
{ //plgDispatch::Dispatch()->RegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey());
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
void pfSecurePreloader::Start()
{ {
#ifndef PLASMA_EXTERNAL_RELEASE #ifndef PLASMA_EXTERNAL_RELEASE
// in internal releases, we can use on-disk files if they exist // Using local data? Move along, move along...
// Build the search string as "dir\\*.ext" if (gDataServerLocal)
wchar searchStr[MAX_PATH]; {
Finish();
PathAddFilename(searchStr, fRequests[curRequest].fPath.c_str(), L"*", arrsize(searchStr)); return;
PathSetExtension(searchStr, searchStr, fRequests[curRequest].fExt.c_str(), arrsize(searchStr)); }
#endif
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 NetCliAuthGetEncryptionKey(fEncryptionKey, 4);
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; // TODO: Localize
fProgress = plProgressMgr::GetInstance()->RegisterOperation(0.0f, "Checking for Updates", plProgressMgr::kUpdateText, false, true);
fFileInfoMap[info.fOriginalNameAndPath] = info; // Now, we need to fetch the "SecurePreloader" manifest from the file server, which will contain the python and SDL files.
curFile++; // We're basically reimplementing plResPatcher here, except preferring to keep everything in memory, then flush to disk
// when we're done. If this fails, then we shall download everything from the AuthSrv like in the old days.
NetCliFileManifestRequest(GotFileSrvManifest, this, L"SecurePreloader");
} }
#endif // PLASMA_EXTERNAL_RELEASE
NetCliAuthFileListRequest( void pfSecurePreloader::Terminate()
fRequests[curRequest].fPath.c_str(),
fRequests[curRequest].fExt.c_str(),
&DefaultFileListRequestCallback,
(void*)this
);
}
}
}
// closes all file pointers and cleans up after itself
void pfSecurePreloader::Cleanup()
{ {
ICleanupStreams(); FATAL("pfSecurePreloader failure");
fRequests.clear();
fFileInfoMap.clear();
fNumInfoRequestsRemaining = 0;
fTotalDataDownload = 0;
fTotalDataReceived = 0;
DEL(fProgressBar); plPreloaderMsg* msg = new plPreloaderMsg;
fProgressBar = nil; msg->fSuccess = false;
plgDispatch::Dispatch()->MsgSend(msg);
} }
//============================================================================ 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) {
DEL(fProgressBar);
fProgressBar = plProgressMgr::GetInstance()->RegisterOperation((hsScalar)(fTotalDataDownload), "Downloading...", plProgressMgr::kUpdateText, false, true);
// Issue some file download requests (up to kMaxConcurrency) // Takes care of UnReffing us
IIssueDownloadRequests(); UnRegisterAs(kSecurePreloader_KEY);
}
else {
IPreloadComplete();
}
} }
//============================================================================ void pfSecurePreloader::PreloadManifest(const NetCliAuthFileInfo manifestEntries[], UInt32 entryCount)
void pfSecurePreloader::IIssueDownloadRequests () {
std::map<std::wstring, fileInfo>::iterator curFile;
for (curFile = fFileInfoMap.begin(); curFile != fFileInfoMap.end(); curFile++)
{ {
// Skip files already downloaded or currently downloading UInt32 totalBytes = 0;
if (curFile->second.fDownloaded || curFile->second.fDownloading) if (fProgress)
continue; totalBytes = (UInt32)fProgress->GetMax();
fLegacyMode = true;
std::wstring filename = curFile->second.fOriginalNameAndPath; for (UInt32 i = 0; i < entryCount; ++i)
#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 const NetCliAuthFileInfo mfs = manifestEntries[i];
fDownloadEntries.push(wcsdup(mfs.filename));
// a local key overrides the server-downloaded key if (IsZipped(mfs.filename))
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
bool added = plStreamSource::GetInstance()->InsertFile(filename.c_str(), stream);
if (!added)
DEL(stream); // wasn't added, so nuke our local copy
// and make sure the vars are set up right
curFile->second.fDownloaded = true;
curFile->second.fLocal = true;
}
else
#endif
{ {
// Enforce concurrency limit wchar_t* name = wcsdup(mfs.filename);
if (fNumDownloadRequestsRemaining >= kMaxConcurrency) plFileUtils::StripExt(name);
break; fManifestEntries.push(name);
curFile->second.fDownloading = true; } else
curFile->second.fDownloaded = false; fManifestEntries.push(wcsdup(mfs.filename));
curFile->second.fLocal = false;
// create and setup the stream totalBytes += mfs.filesize;
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) if (fProgress)
IPreloadComplete();
}
void pfSecurePreloader::UpdateProgressBar(UInt32 bytesReceived)
{ {
fTotalDataReceived += bytesReceived; fProgress->SetLength((hsScalar)totalBytes);
if (fTotalDataReceived > fTotalDataDownload) fProgress->SetTitle("Downloading...");
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 (;;)
{ {
if (fFileInfoMap.find(filename) == fFileInfoMap.end()) UInt32 totalBytes = 0;
for (UInt32 i = 0; i < entryCount; ++i)
{ {
// file doesn't exist... abort const NetCliFileManifestEntry mfs = manifestEntries[i];
succeeded = false; bool fetchMe = true;
break; hsRAMStream* s = nil;
}
fFileInfoMap[filename].fDownloading = false;
// close and delete the writer stream (even if we failed) if (plFileUtils::FileExists(mfs.clientName))
fD2DStreams[filename]->Close();
delete fD2DStreams[filename];
fD2DStreams.erase(fD2DStreams.find(filename));
if (succeeded)
{ {
// 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
fFileInfoMap[filename].fDownloaded = true; // Now actually copare the hashes
break; plMD5Checksum lclHash;
lclHash.CalcFromStream(s);
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);
} }
//============================================================================ if (s)
void pfSecurePreloader::INotifyAuthReconnected () { delete s;
// 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 (totalBytes && fProgress)
{
LogMsg(kLogPerf, L"pfSecurePreloader: Auth reconnected, resetting in-progress file downloads"); fProgress->SetLength((hsScalar)totalBytes);
fProgress->SetTitle("Downloading...");
// Issue some file download requests (up to kMaxConcurrency)
IIssueDownloadRequests();
}
*/
} }
//============================================================================ // This method uses only one manifest, so we're good to go now!
void pfSecurePreloader::IPreloadComplete () { PreloadNextFile();
DEL(fProgressBar);
fProgressBar = nil;
plPreloaderMsg * msg = TRACKED_NEW plPreloaderMsg();
msg->fSuccess = !fNetError;
msg->Send();
} }
//============================================================================ void pfSecurePreloader::FilePreloaded(const wchar_t* file, hsStream* stream)
hsBool pfSecurePreloader::MsgReceive (plMessage * msg) { {
// Clear out queue
if (plNetCommAuthConnectedMsg * authMsg = plNetCommAuthConnectedMsg::ConvertNoRef(msg)) { fDownloadEntries.pop();
const wchar_t* clientName = fManifestEntries.front(); // Stolen by plStreamSource
INotifyAuthReconnected(); fManifestEntries.pop();
return true;
}
return hsKeyedObject::MsgReceive(msg); if (!fLegacyMode) // AuthSrv data caching is useless
{
plFileUtils::EnsureFilePathExists(clientName);
SaveFile(stream, clientName);
} }
//============================================================================ plSecureStream* ss = new plSecureStream(stream, fEncryptionKey);
pfSecurePreloader * pfSecurePreloader::GetInstance () { plStreamSource::GetInstance()->InsertFile(clientName, ss);
delete stream; // SecureStream holds its own decrypted buffer
if (!fInstance) { // Continue down the warpath
PreloadNextFile();
fInstance = NEWZERO(pfSecurePreloader);
fInstance->RegisterAs(kSecurePreloader_KEY);
} }
pfSecurePreloader* pfSecurePreloader::GetInstance()
{
if (!fInstance)
fInstance = new pfSecurePreloader;
return fInstance; return fInstance;
} }
//============================================================================
bool pfSecurePreloader::IsInstanced () {
return fInstance != nil;
}
//============================================================================
void pfSecurePreloader::Init () {
if (!fInitialized) {
fInitialized = true;
plgDispatch::Dispatch()->RegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey());
}
}
//============================================================================
void pfSecurePreloader::Shutdown () {
if (fInitialized) {
fInitialized = false;
plgDispatch::Dispatch()->UnRegisterForExactType(plNetCommAuthConnectedMsg::Index(), GetKey());
}
if (fInstance) {
fInstance->UnRegister();
fInstance = nil;
}
}
//============================================================================
pfSecurePreloader::pfSecurePreloader () {
}
//============================================================================
pfSecurePreloader::~pfSecurePreloader () {
Cleanup();
}

85
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; static pfSecurePreloader* fInstance;
std::queue<const wchar_t*> fManifestEntries;
void IIssueDownloadRequests (); std::queue<const wchar_t*> fDownloadEntries;
void IPreloadComplete (); plOperationProgress* fProgress;
UInt32 fEncryptionKey[4];
void ICleanupStreams(); // closes and deletes all streams bool fLegacyMode;
void INotifyAuthReconnected (); hsRAMStream* LoadToMemory(const wchar_t* file) const;
void SaveFile(hsStream* file, const wchar_t* name) const;
bool IsZipped(const wchar_t* filename) const;
public:
pfSecurePreloader(); pfSecurePreloader();
~pfSecurePreloader();
public:
CLASSNAME_REGISTER(pfSecurePreloader); CLASSNAME_REGISTER(pfSecurePreloader);
GETINTERFACE_ANY(pfSecurePreloader, hsKeyedObject); GETINTERFACE_ANY(pfSecurePreloader, hsKeyedObject);
~pfSecurePreloader ();
void Init(); void Init();
void Start();
void Terminate();
void Finish();
void Shutdown(); void Shutdown();
// Client interface functions void PreloadManifest(const NetCliFileManifestEntry manifestEntries[], UInt32 entryCount);
void RequestSingleFile(std::wstring filename); // queues a single file to be preloaded (does nothing if already preloaded) void PreloadManifest(const NetCliAuthFileInfo manifestEntries[], UInt32 entryCount);
void RequestFileGroup(std::wstring dir, std::wstring ext); // queues a group of files to be preloaded (does nothing if already preloaded) void PreloadNextFile();
void Start(); // sends all queued requests (does nothing if already preloaded) void FilePreloaded(const wchar_t* filename, hsStream* stream);
void Cleanup(); // closes all file pointers and cleans up after itself
// Functions for the network callbacks plOperationProgress* GetProgressBar() { return fProgress; }
void RequestFinished(const std::vector<std::wstring> & filenames, const std::vector<UInt32> & sizes, bool succeeded);
void UpdateProgressBar(UInt32 bytesReceived);
void FinishedDownload(std::wstring filename, bool succeeded);
// Instance handling
static pfSecurePreloader* GetInstance(); static pfSecurePreloader* GetInstance();
static bool IsInstanced (); static void SetInstance(pfSecurePreloader* instance) { fInstance = instance; }
// hsKeyedObject
hsBool MsgReceive (plMessage * msg);
}; };
#endif // __pfSecurePreloader_h__ #endif // __pfSecurePreloader_h__

22
Sources/Plasma/PubUtilLib/plEncryption/plChecksum.cpp
Unescape View File

@ -91,6 +91,11 @@ plMD5Checksum::plMD5Checksum( const char *fileName )
CalcFromFile( fileName ); CalcFromFile( fileName );
} }
plMD5Checksum::plMD5Checksum( hsStream* stream )
{
CalcFromStream(stream);
}
void plMD5Checksum::Clear() void plMD5Checksum::Clear()
{ {
memset( fChecksum, 0, sizeof( fChecksum ) ); memset( fChecksum, 0, sizeof( fChecksum ) );
@ -99,23 +104,30 @@ void plMD5Checksum::Clear()
void plMD5Checksum::CalcFromFile( const char *fileName ) void plMD5Checksum::CalcFromFile( const char *fileName )
{ {
FILE *fp; hsUNIXStream s;
fValid = false; fValid = false;
if( fp = fopen(fileName, "rb" ) ) if( s.Open(fileName) )
{
CalcFromStream(&s);
s.Close();
}
}
void plMD5Checksum::CalcFromStream( hsStream* stream )
{ {
UInt32 sPos = stream->GetPosition();
unsigned loadLen = 1024 * 1024; unsigned loadLen = 1024 * 1024;
Start(); Start();
UInt8 *buf = TRACKED_NEW UInt8[loadLen]; UInt8 *buf = TRACKED_NEW UInt8[loadLen];
while(int read = fread(buf, sizeof(UInt8), loadLen, fp)) while(int read = stream->Read(loadLen, buf))
AddTo( read, buf ); AddTo( read, buf );
delete[] buf; delete[] buf;
Finish(); Finish();
fclose(fp); stream->SetPosition(sPos);
}
} }
void plMD5Checksum::Start( void ) void plMD5Checksum::Start( void )

4
Sources/Plasma/PubUtilLib/plEncryption/plChecksum.h
Unescape View File

@ -58,6 +58,8 @@ public:
SumStorage GetChecksum() { return fSum; } SumStorage GetChecksum() { return fSum; }
}; };
class hsStream;
class plMD5Checksum class plMD5Checksum
{ {
protected: protected:
@ -74,11 +76,13 @@ class plMD5Checksum
plMD5Checksum(); plMD5Checksum();
plMD5Checksum( const plMD5Checksum &rhs ); plMD5Checksum( const plMD5Checksum &rhs );
plMD5Checksum( const char *fileName ); plMD5Checksum( const char *fileName );
plMD5Checksum( hsStream* stream );
hsBool IsValid( void ) const { return fValid; } hsBool IsValid( void ) const { return fValid; }
void Clear(); void Clear();
void CalcFromFile( const char *fileName ); void CalcFromFile( const char *fileName );
void CalcFromStream( hsStream* stream );
void Start( void ); void Start( void );
void AddTo( UInt32 size, const UInt8 *buffer ); void AddTo( UInt32 size, const UInt8 *buffer );

7
Sources/Plasma/PubUtilLib/plFile/plFileUtils.cpp
Unescape View File

@ -413,6 +413,13 @@ void plFileUtils::StripExt(char* fileName)
*(ext-1) = '\0'; *(ext-1) = '\0';
} }
void plFileUtils::StripExt(wchar* fileName)
{
wchar* ext = (wchar*)GetFileExt(fileName);
if (ext)
*(ext-1) = L'\0';
}
const char* plFileUtils::GetFileExt(const char* pathAndName) const char* plFileUtils::GetFileExt(const char* pathAndName)
{ {
const char* fileName = GetFileName(pathAndName); const char* fileName = GetFileName(pathAndName);

1
Sources/Plasma/PubUtilLib/plFile/plFileUtils.h
Unescape View File

@ -100,6 +100,7 @@ namespace plFileUtils
void StripFile(char* pathAndName); void StripFile(char* pathAndName);
void StripFile(wchar* pathAndName); void StripFile(wchar* pathAndName);
void StripExt(char* fileName); void StripExt(char* fileName);
void StripExt(wchar* fileName);
// Get the size of the given file in bytes // Get the size of the given file in bytes
UInt32 GetFileSize( const char *path ); UInt32 GetFileSize( const char *path );

57
Sources/Plasma/PubUtilLib/plFile/plSecureStream.cpp
Unescape View File

@ -77,6 +77,22 @@ fDeleteOnExit(deleteOnExit)
memcpy(&fKey, &kDefaultKey, sizeof(kDefaultKey)); memcpy(&fKey, &kDefaultKey, sizeof(kDefaultKey));
} }
plSecureStream::plSecureStream(hsStream* base, UInt32* key) :
fRef(INVALID_HANDLE_VALUE),
fActualFileSize(0),
fBufferedStream(false),
fRAMStream(nil),
fWriteFileName(nil),
fOpenMode(kOpenFail),
fDeleteOnExit(false)
{
if (key)
memcpy(&fKey, key, sizeof(kDefaultKey));
else
memcpy(&fKey, &kDefaultKey, sizeof(kDefaultKey));
Open(base);
}
plSecureStream::~plSecureStream() plSecureStream::~plSecureStream()
{ {
} }
@ -232,6 +248,39 @@ hsBool plSecureStream::Open(const wchar* name, const wchar* mode)
} }
} }
hsBool plSecureStream::Open(hsStream* stream)
{
UInt32 pos = stream->GetPosition();
stream->Rewind();
if (!ICheckMagicString(stream))
return false;
fActualFileSize = stream->ReadLE32();
UInt32 trimSize = kMagicStringLen + sizeof(UInt32) + fActualFileSize;
fRAMStream = new hsRAMStream;
while (!stream->AtEnd())
{
// Don't write out any garbage
UInt32 size;
if ((trimSize - stream->GetPosition()) < kEncryptChunkSize)
size = (trimSize - stream->GetPosition());
else
size = kEncryptChunkSize;
UInt8 buf[kEncryptChunkSize];
stream->Read(kEncryptChunkSize, &buf);
IDecipher((UInt32*)&buf, kEncryptChunkSize / sizeof(UInt32));
fRAMStream->Write(size, &buf);
}
stream->SetPosition(pos);
fRAMStream->Rewind();
fPosition = 0;
fBufferedStream = true;
fOpenMode = kOpenRead;
return true;
}
hsBool plSecureStream::Close() hsBool plSecureStream::Close()
{ {
int rtn = false; int rtn = false;
@ -598,6 +647,14 @@ bool plSecureStream::FileDecrypt(const wchar* fileName, UInt32* key /* = nil */)
return true; return true;
} }
bool plSecureStream::ICheckMagicString(hsStream* s)
{
char magicString[kMagicStringLen+1];
s->Read(kMagicStringLen, &magicString);
magicString[kMagicStringLen] = '\0';
return (hsStrEQ(magicString, kMagicString) != 0);
}
bool plSecureStream::ICheckMagicString(hsFD fp) bool plSecureStream::ICheckMagicString(hsFD fp)
{ {
char magicString[kMagicStringLen+1]; char magicString[kMagicStringLen+1];

3
Sources/Plasma/PubUtilLib/plFile/plSecureStream.h
Unescape View File

@ -85,13 +85,16 @@ protected:
bool IWriteEncrypted(hsStream* sourceStream, const wchar* outputFile); bool IWriteEncrypted(hsStream* sourceStream, const wchar* outputFile);
static bool ICheckMagicString(hsFD fp); static bool ICheckMagicString(hsFD fp);
static bool ICheckMagicString(hsStream* s);
public: public:
plSecureStream(hsBool deleteOnExit = false, UInt32* key = nil); // uses default key if you don't pass one in plSecureStream(hsBool deleteOnExit = false, UInt32* key = nil); // uses default key if you don't pass one in
plSecureStream(hsStream* base, UInt32* key = nil);
~plSecureStream(); ~plSecureStream();
virtual hsBool Open(const char* name, const char* mode = "rb"); virtual hsBool Open(const char* name, const char* mode = "rb");
virtual hsBool Open(const wchar* name, const wchar* mode = L"rb"); virtual hsBool Open(const wchar* name, const wchar* mode = L"rb");
hsBool Open(hsStream* stream);
virtual hsBool Close(); virtual hsBool Close();
virtual UInt32 Read(UInt32 byteCount, void* buffer); virtual UInt32 Read(UInt32 byteCount, void* buffer);

7
Sources/Plasma/PubUtilLib/plFile/plStreamSource.cpp
Unescape View File

@ -128,7 +128,12 @@ hsStream* plStreamSource::GetFile(std::wstring filename)
if (plSecureStream::IsSecureFile(sFilename.c_str())) if (plSecureStream::IsSecureFile(sFilename.c_str()))
{ {
UInt32 encryptionKey[4]; UInt32 encryptionKey[4];
plFileUtils::GetSecureEncryptionKey(sFilename.c_str(), encryptionKey, 4); if (!plFileUtils::GetSecureEncryptionKey(sFilename.c_str(), encryptionKey, 4))
{
FATAL("Hey camper... You need an NTD key file!");
return nil;
}
fFileData[filename].fStream = plSecureStream::OpenSecureFile(sFilename.c_str(), 0, encryptionKey); fFileData[filename].fStream = plSecureStream::OpenSecureFile(sFilename.c_str(), 0, encryptionKey);
} }
else // otherwise it is an encrypted or plain stream, this call handles both else // otherwise it is an encrypted or plain stream, this call handles both

Write Preview
Loading…
Cancel
Save