/* This is meant to find and open files for reading. */
FileReader *open_filereader(const char *name, int open, int *plumpnum)
{
FileReader *fp;
FString current_filename;
if (!name || !(*name))
{
return 0;
}
/* First try the given name */
current_filename = name;
FixPathSeperator(current_filename);
int lumpnum = Wads.CheckNumForFullName(current_filename);
if (open != OM_FILE)
{
if (lumpnum >= 0)
{
fp = Wads.ReopenLumpNum(lumpnum);
if (plumpnum) *plumpnum = lumpnum;
return fp;
}
if (open == OM_LUMP) // search the path list when not loading the main config
{
for (unsigned int plp = PathList.Size(); plp-- != 0; )
{ /* Try along the path then */
current_filename = BuildPath(PathList[plp], name);
lumpnum = Wads.CheckNumForFullName(current_filename);
if (lumpnum >= 0)
{
fp = Wads.ReopenLumpNum(lumpnum);
if (plumpnum) *plumpnum = lumpnum;
return fp;
}
}
return NULL;
}
}
if (plumpnum) *plumpnum = -1;
fp = new FileReader;
if (fp->Open(current_filename)) return fp;
if (name[0] != '/')
{
for (unsigned int plp = PathList.Size(); plp-- != 0; )
{ /* Try along the path then */
current_filename = BuildPath(PathList[plp], name);
if (fp->Open(current_filename)) return fp;
}
}
delete fp;
/* Nothing could be opened. */
current_filename = "";
return NULL;
}
// 文件加密函数
// 这个函数有点长，但是基本上都是检错的代码。逻辑还是很清晰的。
errno_t EasyEncrypt(const string& inFilename, const string& outFilename, const string& key)
{
LOGPOS();
FileReader fileReader;
FilePath inFilePath(inFilename);
if (fileReader.Open(inFilePath.value()) != CPT_OK) {
LOGW("Open file %s failed!", inFilePath.value().c_str());
return CPT_ERROR;
}
Encrypt encrypt;
if (encrypt.SetReader(dynamic_cast<Reader*>(&fileReader)) != CPT_OK) {
LOGW("Encrypt Set Reader failed");
return CPT_ERROR;
}
FileHeader *fileHeader = encrypt.GenrHeader();
if (fileHeader == NULL) {
LOGW("Generate file header failed!");
return CPT_ERROR;
}
fileHeader->SetFormat(inFilePath.Extension());
if (encrypt.EncryptHeader(key.c_str(), key.length()) != CPT_OK) {
LOGW("Encrypt file header failed");
return CPT_ERROR;
}
FileWriter writer;
if (writer.Open(outFilename) != CPT_OK) {
LOGW("Create file %s failed!", outFilename.c_str());
return CPT_ERROR;
}
if (encrypt.SetWriter(dynamic_cast<Writer*>(&writer)) != CPT_OK) {
LOGW("encrypt set writer failed!");
return CPT_ERROR;
}
if (encrypt.WriteHeader() != CPT_OK) {
LOGW("Encrypt write header failed!");
return CPT_ERROR;
}
int err = encrypt.PreEncrypt();
ASSERT(err == CPT_OK);
if (encrypt.DoEncrypt(key.c_str(), key.length()) != CPT_OK) {
LOGW("Encrypt encrypt failed!");
return CPT_ERROR;
}
err = encrypt.PostEncrypt();
ASSERT(err == CPT_OK);
return CPT_OK;
}
errno_t EasyDecrypt(const string& filename, const string& key, string *outFilename)
{
LOGPOS();
FilePath inFilePath(filename);
FileReader reader;
if (reader.Open(inFilePath.value()) != CPT_OK) {
LOGW("Open file %s failed!", inFilePath.value().c_str());
return CPT_ERROR;
}
Decrypt decrypt;
if (decrypt.SetReader(&reader) != CPT_OK) {
LOGW("Decrypt set reader failed!");
return CPT_ERROR;
}
if (decrypt.LoadHeader() != CPT_OK) {
LOGW("Decrypt load header failed!");
return CPT_ERROR;
}
FileHeader *fileHeader = decrypt.DecryptHeader(key.c_str(), key.length());
if (fileHeader == NULL) {
LOGW("LoadHeader error");
return CPT_ERROR;
}
FilePath outFilePath = inFilePath.ReplaceExtension(fileHeader->GetFormat());
*outFilename = outFilePath.value();
FileWriter writer;
if (writer.Open(outFilePath.value()) != CPT_OK) {
LOGW("Create file %s failed!", outFilePath.value().c_str());
return CPT_ERROR;
}
if (decrypt.SetWriter(dynamic_cast<Writer*>(&writer)) != CPT_OK) {
LOGW("Decrypt set writer failed!");
return CPT_ERROR;
}
int err = decrypt.PreDecrypt();
ASSERT(err == CPT_OK);
if (decrypt.DoDecrypt(key.c_str(), key.length())) {
LOGW("Decrypt decrypt file failed!");
return CPT_ERROR;
}
err = decrypt.PostDecrypt();
ASSERT(err == CPT_OK);
return CPT_OK;
}
errno_t EasyDecryptInMemory(const string& filename, const string& key, MemoryWriter *writer)
{
LOGPOS();
FilePath inFilePath(filename);
FileReader reader;
if (reader.Open(inFilePath.value()) != CPT_OK) {
LOGW("Open file %s failed!", inFilePath.value().c_str());
return CPT_ERROR;
}
uint64_t u64 = 0;
reader.GetLength(&u64);
if (writer->Reserve(u64) != CPT_OK) {
LOGW("MemoryWriter SetLength failed!");
return CPT_ERROR;
}
Decrypt decrypt;
if (decrypt.SetReader(&reader) != CPT_OK) {
LOGW("Decrypt set reader failed!");
return CPT_ERROR;
}
if (decrypt.LoadHeader() != CPT_OK) {
LOGW("Decrypt LoadHeader error");
return CPT_ERROR;
}
if (decrypt.DecryptHeader(key.c_str(), key.length()) == NULL) {
LOGW("LoadHeader error");
return CPT_ERROR;
}
if (decrypt.SetWriter(writer) != CPT_OK) {
LOGW("Decrypt set writer failed!");
return CPT_ERROR;
}
int err = decrypt.PreDecrypt();
ASSERT(err == CPT_OK);
if (decrypt.DoDecrypt(key.c_str(), key.length())) {
LOGW("Decrypt decrypt file failed!");
return CPT_ERROR;
}
err = decrypt.PostDecrypt();
ASSERT(err == CPT_OK);
return CPT_OK;
}
void SPAuthCheckPrv::ReadCheckFile()
{
// Read check prevention file
mGameSecondsBeforeNextCheck = 1; // default -> check
try
{
FileReader aReader;
if(!aReader.Open(gSPAuthCheck_FileName))
return;
unsigned short aNumBytes = aReader.ReadShort();
if(aNumBytes==0 || aReader.Available()<aNumBytes)
return;
char *aBuf = new char[aNumBytes];
std::auto_ptr<char> aDelBuf(aBuf);
aReader.ReadBytes(aBuf,aNumBytes);
aReader.Close();
ByteBufferPtr aDecrypt = mEncryptKey.Decrypt(aBuf,aNumBytes);
if(aDecrypt.get()==NULL)
return;
WONFile aFile(gSPAuthCheck_FileName);
ReadBuffer aReadBuf(aDecrypt->data(),aDecrypt->length());
std::string aSig;
aReadBuf.ReadString(aSig);
if(aSig!="magic")
return;
time_t aCreateTime = aFile.GetCreateTime();
time_t aCompareCreateTime = aReadBuf.ReadLong();
if(aCompareCreateTime != aCreateTime)
return;
mGameSecondsBeforeNextCheck = aReadBuf.ReadLong();
if(mGameSecondsBeforeNextCheck==0) // don't remove file in this case
return;
aFile.Remove();
}
catch(FileReaderException&)
{
}
catch(ReadBufferException&)
{
}
}
bool RPCFile::Open(const char* path)
{
FileReader* file = new FileReader();
if(!file->Open(path))
{
delete file;
return false;
}
bool ret = Open(file);
m_ownFile = true;
return ret;
}
bool
GastofDQM(unsigned int address, string filename, vector<string>* outputs)
{
cout << "filename: " << filename << endl;
FileReader reader;
try { reader.Open(filename); } catch (Exception& e) { throw e; }
if (!reader.IsOpen()) throw Exception(__PRETTY_FUNCTION__, "Failed to build FileReader", JustWarning);
cout << "Run/Burst Id = " << reader.GetRunId() << " / " << reader.GetBurstId() << endl;
const unsigned int num_channels = 32;
double mean_num_events[num_channels], mean_tot[num_channels];
int trigger_td;
unsigned int num_events[num_channels];
enum plots {
kDensity,
kMeanToT,
//kTriggerTimeDiff,
kNumPlots
};
const unsigned short num_plots = kNumPlots;
DQM::GastofCanvas* canv[num_plots];
canv[kDensity] = new DQM::GastofCanvas(Form("gastof_%d_%d_%d_channels_density", reader.GetRunId(), reader.GetBurstId(), address), "Channels density");
canv[kMeanToT] = new DQM::GastofCanvas(Form("gastof_%d_%d_%d_mean_tot", reader.GetRunId(), reader.GetBurstId(), address), "Mean ToT (ns)");
//canv[kTriggerTimeDiff] = new DQM::GastofCanvas(Form("gastof_%d_%d_%d_trigger_time_difference", reader.GetRunId(), reader.GetBurstId(), address), "Time btw. each trigger (ns)");
VME::TDCMeasurement m;
for (unsigned int i=0; i<num_channels; i++) {
unsigned short nino_board, ch_id;
mean_num_events[i] = mean_tot[i] = 0.;
num_events[i] = 0;
trigger_td = 0;
try {
if (i<32) { nino_board = 1; ch_id = i; }
else { nino_board = 0; ch_id = i-32; }
while (true) {
if (!reader.GetNextMeasurement(i, &m)) break;
//if (trigger_td!=0) { canv[kTriggerTimeDiff]->FillChannel(nino_board, ch_id, (m.GetLeadingTime(0)-trigger_td)*25./1.e3); }
trigger_td = m.GetLeadingTime(0);
for (unsigned int j=0; j<m.NumEvents(); j++) {
mean_tot[i] += m.GetToT(j)*25./1.e3/m.NumEvents();
}
mean_num_events[i] += m.NumEvents();
if (m.NumEvents()!=0) num_events[i] += 1;
}
if (num_events[i]>0) {
mean_num_events[i] /= num_events[i];
mean_tot[i] /= num_events[i];
}
canv[kDensity]->FillChannel(nino_board, ch_id, mean_num_events[i]);
canv[kMeanToT]->FillChannel(nino_board, ch_id, mean_tot[i]);
cout << dec;
cout << "Finished extracting channel " << i << ": " << num_events[i] << " measurements, "
<< "mean number of hits: " << mean_num_events[i] << ", "
<< "mean tot: " << mean_tot[i] << endl;
reader.Clear();
} catch (Exception& e) {
e.Dump();
if (e.ErrorNumber()<41000) throw e;
}
}
for (unsigned int i=0; i<num_plots; i++) {
canv[i]->SetRunInfo(address, reader.GetRunId(), reader.GetBurstId(), TDatime().AsString());
canv[i]->Save("png", DQM_OUTPUT_DIR);
outputs->push_back(canv[i]->GetName());
}
return true;
}
bool ProcessDemoFile(const char* filePath)
{
for(u32 i = 0; i < ID_MAX_CLIENTS; ++i)
{
_players[i].Name.clear();
_players[i].Valid = false;
}
FileReader reader;
if(!reader.Open(filePath))
{
return false;
}
udtCuContext* const cuContext = _cuContext;
const u32 protocol = udtGetProtocolByFilePath(filePath);
const s32 firstPlayerIdx = udtGetIdConfigStringIndex((u32)udtConfigStringIndex::FirstPlayer, protocol);
if(firstPlayerIdx < 0)
{
PrintError("Failed to get the first index of player config strings");
return false;
}
_protocol = (udtProtocol::Id)protocol;
_protocolFirstPlayerCsIdx = firstPlayerIdx;
s32 errorCode = udtCuStartParsing(cuContext, protocol);
if(errorCode != udtErrorCode::None)
{
PrintError("udtCuStartParsing failed: %s", udtGetErrorCodeString(errorCode));
return false;
}
udtCuMessageInput input;
udtCuMessageOutput output;
u32 continueParsing = 0;
for(;;)
{
if(!reader.Read(&input.MessageSequence, 4))
{
PrintWarning("Demo is truncated");
return true;
}
if(!reader.Read(&input.BufferByteCount, 4))
{
PrintWarning("Demo is truncated");
return true;
}
if(input.MessageSequence == -1 &&
input.BufferByteCount == u32(-1))
{
// End of demo file.
break;
}
if(input.BufferByteCount > ID_MAX_MSG_LENGTH)
{
PrintError("Corrupt input: the buffer length exceeds the maximum allowed");
return false;
}
if(!reader.Read(_inMsgData, input.BufferByteCount))
{
PrintWarning("Demo is truncated");
return true;
}
input.Buffer = _inMsgData;
errorCode = udtCuParseMessage(cuContext, &output, &continueParsing, &input);
if(errorCode != udtErrorCode::None)
{
PrintError("udtCuParseMessage failed: %s", udtGetErrorCodeString(errorCode));
return false;
}
if(continueParsing == 0)
{
break;
}
AnalyzeMessage(output);
}
return true;
}
void BenchmarkDArray(Sorter<char *> &sorter)
{
DArray<char *> data, rdata;
Stopwatch sw;
char buffer[512], format[64];
sprintf(format, "%s", "%4.3lfs");
FileReader file;
file.SetLineEndings(CC_LN_LF);
file.Open("dataset");
if (file.IsOpen()) {
data.setStepDouble();
rdata.setStepDouble();
console->Write("Loading... ");
sw.Start();
/* Load the file into the data DArray */
while (file.ReadLine(buffer, sizeof(buffer)) >= 0)
data.insert(cc_strdup(buffer));
sw.Stop();
console->WriteLine(format, sw.Elapsed());
file.Close();
console->WriteLine("Loaded %d items.", data.used());
console->Write("Random: ");
sw.Start();
data.sort(sorter);
sw.Stop();
console->WriteLine(format, sw.Elapsed());
/* Create a reverse-sorted DArray */
for (long i = (long)data.size(); i >= 0; i--) {
if (data.valid(i)) {
rdata.insert(data.get(i));
}
}
console->Write("Pre-sorted: ");
sw.Start();
data.sort(sorter);
sw.Stop();
console->WriteLine(format, sw.Elapsed());
console->Write("Reverse-sorted: ");
sw.Start();
rdata.sort(sorter);
sw.Stop();
console->WriteLine(format, sw.Elapsed());
for (size_t i = 0; i < data.size(); i++) {
if (data.valid(i)) {
free(data.get(i));
data.remove(i);
}
}
data.empty();
rdata.empty();
} else {
console->WriteLine("Dataset not found.");
}
}
bool ParseReplay(const char *pszFilename, DWORD dwFlags)
{
// Open replay file
FileReader fr;
if ( !fr.Open(pszFilename) )
return false;
///////////////////// Header
// Read replay resource identifier
DWORD dwRepResourceID = 0;
// Best guess: "reRS" is "replay RESOURCE"
if ( !DecompressRead(&dwRepResourceID, sizeof(dwRepResourceID), fr) || dwRepResourceID != mmioFOURCC('r','e','R','S') )
return errSimple("No Replay resource ID found.");
// Read replay resource header
if ( !DecompressRead(&replayHeader, sizeof(replayHeader), fr) )
return errSimple("Unable to read replay header.");
////////////////// Actions
// Read replay actions section size
DWORD dwActionBufferSize = 0;
if ( !DecompressRead(&dwActionBufferSize, 4, fr) )
return errSimple("Unable to read actions size.");
// Allocate and Read replay actions
void *pActionBuffer = malloc(dwActionBufferSize);
FileReader frActions(pActionBuffer, dwActionBufferSize);
if ( dwActionBufferSize && !DecompressRead(pActionBuffer, dwActionBufferSize, fr) )
return errSimple("Decompressing actions failed.");
/////////////////// Map Chk
// get map chunk data size
DWORD dwChkBufferSize = 0;
if ( !DecompressRead(&dwChkBufferSize, 4, fr) )
return errSimple("Unable to read chk size.");
// Allocate and Read chk data
void *pChkBuffer = malloc(dwChkBufferSize);
//FileReader frChk(pChkBuffer, dwChkBufferSize);
if ( dwChkBufferSize && !DecompressRead(pChkBuffer, dwChkBufferSize, fr) )
return errSimple("Decompressing map failed.");
// Write extracted replay data
if ( dwFlags & RFLAG_EXTRACT )
{
WriteBuffer("%s.hdr", pszFilename, &replayHeader, sizeof(replayHeader));
WriteBuffer("%s.act", pszFilename, pActionBuffer, dwActionBufferSize);
WriteBuffer("%s.chk", pszFilename, pChkBuffer, dwChkBufferSize);
}
// parse data for repair
if ( dwFlags & RFLAG_REPAIR )
{
// Parse replay actions
ParseActions(frActions);
if ( replayHeader.dwFrameCount < g_dwHighestFrame )
{
char szTmp[256];
sprintf(szTmp, "Fixed replay with %u frames. Desired: %u frames.", replayHeader.dwFrameCount, g_dwHighestFrame);
MessageBox(NULL, szTmp, "Fixed", 0);
//replayHeader.dwFrameCount = g_dwHighestFrame + 10;
}
FileWriter fw;
fw.Open(pszFilename);
// write rep resource id
dwRepResourceID = mmioFOURCC('r','e','R','S');
CompressWrite(&dwRepResourceID, sizeof(dwRepResourceID), fw);
// write header
CompressWrite(&replayHeader, sizeof(replayHeader), fw);
// write actions
CompressWrite(&dwActionBufferSize, sizeof(dwActionBufferSize), fw);
if ( dwActionBufferSize )
CompressWrite(pActionBuffer, dwActionBufferSize, fw);
// write chk
CompressWrite(&dwChkBufferSize, sizeof(dwChkBufferSize), fw);
if ( dwChkBufferSize )
CompressWrite(pChkBuffer, dwChkBufferSize, fw);
}
return true;
}
