Verts& readResult(cstring rpath){
FILE* fp;
//auto rpath = "C:\\Users\\master8\\Downloads\\solid-3.5.7\\result";
let err=fopen_s(&fp, rpath, "rb");
Verts& v = *(new std::vector<float>);
if (!err){
int* len=new int;
fread_s(len, sizeof len, 4, 1, fp);
int l = *len;
float* cenext=new float[6*l];
auto fl = sizeof(float);
for (size_t i = 0; i < l; i+=6)
{
fread_s(&cenext[i], fl*6, fl*6, 1, fp); //l countロードすれば一気に
v.push_back(cenext[i]);
v.push_back(cenext[i+1]);
v.push_back(cenext[i+2]);
v.push_back(cenext[i+3]);
v.push_back(cenext[i+4]);
v.push_back(cenext[i+5]);
}
fclose(fp);
delete len;
delete cenext;
}
return v;
}
CSFAPI int CSFile_load(CSFile** outcsf, const char* filename, CSFileMemoryPTR mem)
{
FILE* file;
if (fopen_s(&file,filename,"rb")){
*outcsf = 0;
return CADSCENEFILE_ERROR_NOFILE;
}
CSFile header;
size_t sizeshould = 0;
if (!fread_s(&header,sizeof(header),sizeof(header),1,file) ||
!(sizeshould=CSFile_getRawSize(&header)))
{
fclose(file);
*outcsf = 0;
return CADSCENEFILE_ERROR_VERSION;
}
// load the full file to memory
xfseek(file, 0, SEEK_END);
size_t size = (size_t)xftell(file);
xfseek(file, 0, SEEK_SET);
if (sizeshould != size){
fclose(file);
*outcsf = 0;
return CADSCENEFILE_ERROR_VERSION;
}
char* data = (char*)mem->alloc(size);
fread_s(data,size,size,1,file);
fclose(file);
return CSFile_loadRaw(outcsf,size,data);
}
bool tdnMesh::LoadTDNM(FILE* file, const char* fileName)
{
unsigned int vertexSize( sizeof( MESHVERTEX2 ) );
// 頂点読み込み
numVertexes = 0;
fread_s( &numVertexes, sizeof( numVertexes ), sizeof( numVertexes ), 1, file );
delete[] vertexArray;
vertexArray = new MESHVERTEX2[numVertexes];
fread_s( vertexArray, vertexSize * numVertexes, vertexSize * numVertexes, 1, file );
if ( !CreateVertex( numVertexes, sizeof( MESHVERTEX2 ), vertexArray ) )
return false;
// インデックス設定
DWORD* indexArray = new DWORD[numVertexes];
for ( unsigned int i = 0; i < numVertexes; i++ )
{
indexArray[i] = i;
}
CreateIndexes( numVertexes, indexArray );
delete[]indexArray;
// 面数
numFaces = numVertexes / 3;
// 頂点情報
D3DVERTEXELEMENT9 declAry[] = {
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, // 位置
{ 0, sizeof( float ) * 3, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, // 法線
{ 0, sizeof( float ) * 6, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 }, // 頂点色
{ 0, sizeof( float ) * 6 + sizeof( COLOR ), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, // UV座標
D3DDECL_END()
};
CreateDeclaration( sizeof( MESHVERTEX2 ), declAry );
// テクスチャ読み込み
std::string workFileName = fileName;
unsigned int filePathLength = workFileName.find_last_of('/');
if (filePathLength == std::string::npos)
filePathLength = workFileName.find_last_of('\\');
workFileName = workFileName.substr(0, filePathLength + 1);
size_t textureNameLen( 0 );
fread_s( &textureNameLen, sizeof( size_t ), sizeof( size_t ), 1, file );
delete[] textureName;
textureName = new char[textureNameLen + 1];
fread_s( textureName, textureNameLen + 1, textureNameLen, 1, file );
textureName[textureNameLen] = '\0';
workFileName += textureName;
texture = tdnTexture::Load(workFileName.c_str());
return true;
}
HRESULT STDMETHODCALLTYPE D3DIncludeCallback::Open(THIS_ D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes)
{
String strPath = ".\\shader\\";
strPath.append( pFileName );
FILE* pFile = NULL;
if( 0 != fopen_s( &pFile , strPath.c_str() , "rb" ) )
{
return S_FALSE;
}
ZP_ASSERT( pFile != NULL );
fseek( pFile , 0 , SEEK_END );
int iFileLen = ftell( pFile );
void* pBuf = new char[iFileLen+1];
ZP_ASSERT( NULL != pBuf );
memset( pBuf , 0 , iFileLen+1);
fseek( pFile , 0 , SEEK_SET );
*pBytes = fread_s( pBuf , iFileLen+1 , 1 , iFileLen , pFile );
*ppData = pBuf;
fclose( pFile );
pFile = NULL;
return S_OK;
}
/// @brief 构造函数
/// @param[in] pFilePath 文件路径
explicit CMNISTLabelFile(IN const char* pFilePath)
{
m_pFile = 0;
if (pFilePath == 0)
return;
fopen_s(&m_pFile, pFilePath, "rb");
if (m_pFile == 0)
return;
unsigned char fileHeaderBuffer[LABEL_FILE_HEADER_SIZE] = { 0 };
size_t count = fread_s(fileHeaderBuffer, LABEL_FILE_HEADER_SIZE, LABEL_FILE_HEADER_SIZE, 1, m_pFile);
if (count != 1)
return;
// 将大端模式转换为小端模式
for (unsigned int i = 0; i < LABEL_FILE_HEADER_SIZE; i += 4)
{
unsigned char temp = fileHeaderBuffer[i];
fileHeaderBuffer[i] = fileHeaderBuffer[i + 3];
fileHeaderBuffer[i + 3] = temp;
temp = fileHeaderBuffer[i + 1];;
fileHeaderBuffer[i + 1] = fileHeaderBuffer[i + 2];
fileHeaderBuffer[i + 2] = temp;
}
m_labelNum = *(unsigned int*)(fileHeaderBuffer + 4);
}
PLAY * Play_Perst_FetchByID(int ID)
{
FILE *fp;
errno_t err;
PLAY *play_temp;
if ((err = fopen_s(&fp, "Play.dat", "rb") != 0))
{
return nullptr;
}
else
{
fseek(fp, 0, SEEK_END);
if (ftell(fp) == 0)
{
fclose(fp);
return nullptr;
}
fseek(fp, 0, SEEK_SET);
while (!feof(fp))
{
play_temp = static_cast<PLAY *>(malloc(sizeof(PLAY)));
fread_s(play_temp, sizeof(PLAY), sizeof(PLAY), 1, fp);
if (play_temp->data.id == ID)
{
fclose(fp);
return play_temp;
}
}
}
fclose(fp);
return nullptr;
}
int SaleData_Perst_FentchByUser(char UserAccount[])
{
FILE *fp;
errno_t err;
SALE *SaleData_temp;
auto Count = 0;
if (err = fopen_s(&fp, "Sale.dat", "rb") != 0)
{
return 0;
}
else
{
fseek(fp, 0, SEEK_END);
if (ftell(fp) == 0)
{
fclose(fp);
return 0;
}
fseek(fp, 0, SEEK_SET);
while (!feof(fp))
{
SaleData_temp = static_cast<SALE *>(malloc(sizeof(SALE)));
fread_s(SaleData_temp, sizeof(SALE), sizeof(SALE), 1, fp);
if (strcmp(SaleData_temp->data.UserAcc,UserAccount) == 0)
{
fclose(fp);
return SaleData_temp->data.id;
}
}
}
fclose(fp);
return Count;
}
/*
char GracePeriodStore[GRACE_PERIOD_STORE_SIZE] = "RoundBrownFoxJumpedTheFence";
int LoadCurrectGracePeriodDataDLL(GraceStatusResourceStore *StaticDLLResourceDataInFile, long *StaticDataStoredAt)
{
//make sure we do not return uninitialized values
memset(StaticDLLResourceDataInFile, 0, sizeof(GraceStatusResourceStore));
//open self DLL
FILE *f;
errno_t er = fopen_s(&f, "LicenseDLL.dll", "rb");
if (er != NO_ERROR)
return er;
if (f == NULL)
return ERROR_FILE_INVALID;
GraceStatusResourceStore *StaticDLLResourceDataInMemory = (GraceStatusResourceStore *)GracePeriodStore;
//search for our resource store header
#define FileReadBlockSize (10 * 1024 * 1024) //our dll file should be about 150k
int FileSize = GetFileSize("LicenseDLL.dll");
if (FileSize <= 0)
FileSize = FileReadBlockSize;
unsigned char *FileContentBuffered = (unsigned char *)malloc(FileSize);
size_t ReadCount = fread_s(FileContentBuffered, FileSize, 1, FileSize, f);
*StaticDataStoredAt = 0;
for (size_t i = 0; i < ReadCount; i++)
if (memcmp(&FileContentBuffered[i], StaticDLLResourceDataInMemory->Header, sizeof(StaticDLLResourceDataInMemory->Header)) == 0)
{
if (StaticDLLResourceDataInFile != NULL)
memcpy(StaticDLLResourceDataInFile, &FileContentBuffered[i], sizeof(GraceStatusResourceStore));
*StaticDataStoredAt = i;
break;
}
free(FileContentBuffered);
fclose(f);
//if data is encoded, decode it
int erEncrypt = CODECGraceData(StaticDLLResourceDataInFile, 0);
//pass through errors
return erEncrypt;
}
*/
int LoadCurrectGracePeriodDataFile(const char *FileName,GraceStatusResourceStore *StaticDLLResourceDataInFile)
{
//make sure we do not return uninitialized values
memset(StaticDLLResourceDataInFile, 0, sizeof(GraceStatusResourceStore));
FILE *f;
errno_t er = fopen_s(&f, FileName, "rb");
if (er != NO_ERROR)
return er;
if (f == NULL)
return ERROR_FILE_INVALID;
size_t ReadCount = fread_s(StaticDLLResourceDataInFile, sizeof(GraceStatusResourceStore), 1, sizeof(GraceStatusResourceStore), f);
fclose(f);
if (ReadCount != sizeof(GraceStatusResourceStore))
return ERROR_COULD_NOT_LOAD_GRACE_DATA;
//if data is encoded, decode it
int erEncrypt = CODECGraceData(StaticDLLResourceDataInFile, 0);
if (erEncrypt == 0)
{
if (StaticDLLResourceDataInFile->IsFileInitialized != 1 || StaticDLLResourceDataInFile->StoreVersion != GRACE_STORE_VERSION)
return ERROR_STORE_VERSION_MISMATCH;
}
//pass through errors
return erEncrypt;
}
int Ticket_Perst_FetchBySS(int ScheduleID, int SeatID)
{
FILE *fp;
errno_t err;
TICKET *ticket_temp;
if ((err = fopen_s(&fp, "Ticket.dat", "rb") != 0))
{
return 0;
}
else
{
fseek(fp, 0, SEEK_END);
if (ftell(fp) == 0)
{
fclose(fp);
return 0;
}
fseek(fp, 0, SEEK_SET);
while (!feof(fp))
{
ticket_temp = static_cast<TICKET *>(malloc(sizeof(TICKET)));
fread_s(ticket_temp, sizeof(TICKET), sizeof(TICKET), 1, fp);
if (ticket_temp->data.schedule_id == ScheduleID && ticket_temp->data.seat_id == SeatID)
{
// printf_s("%d %d\n", ticket_temp->data.id, ticket_temp->data.seat_id);
fclose(fp);
return ticket_temp->data.id;
}
}
}
fclose(fp);
return 0;
}
fragshader::fragshader(char * fragfile){
FILE * f;
fopen_s(&f, fragfile, "r");
fseek(f, 0, SEEK_END);
GLint size = ftell(f);
fseek(f, 0, SEEK_SET);
char * fbuf = new char[size + 1];
memset(fbuf, 0, size + 1);
fread_s(fbuf, size + 1, size, 1, f);
_fragshader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(_fragshader, 1, &fbuf, &size);
glCompileShader(_fragshader);
GLint cStatus = 0;
glGetShaderiv(_fragshader, GL_COMPILE_STATUS, &cStatus);
if (GL_FALSE == cStatus) {
GLint logLen;
glGetShaderiv(_fragshader, GL_INFO_LOG_LENGTH, &logLen);
char *log = (char *)malloc(logLen);
glGetShaderInfoLog(_fragshader, GL_INFO_LOG_LENGTH, &logLen, log);
std::cerr << "fragshader log : " << std::endl;
std::cerr << log << std::endl;
}
fclose(f);
}
HRESULT WriteReadShader(ID3DBlob **ppSBlob, const wchar_t *const sTargetFileName)
{
HRESULT hr;
FILE *pFile;
#ifdef AUTSHADERS_SAVE_TO_FILE
_wfopen_s(&pFile, sTargetFileName, L"wb");
fwrite((*ppSBlob)->GetBufferPointer(), (*ppSBlob)->GetBufferSize(), 1, pFile);
fclose(pFile);
#endif
int nSize = 0;
_wfopen_s(&pFile, sTargetFileName, L"rb");
fseek(pFile, 0, SEEK_END);
nSize = ftell(pFile);
fseek(pFile, 0, SEEK_SET);
*ppSBlob = NULL;
V_RETURN(D3DCreateBlob(nSize, ppSBlob));
fread_s((*ppSBlob)->GetBufferPointer(), nSize, nSize, 1, pFile);
fclose(pFile);
return S_OK;
}
// File format:
// name<newline>
// name<newline>
// etc...
bool InitDvarTable(const char *File)
{
FILE *dvarList = nullptr;
// Open file
fopen_s(&dvarList, File, "r");
// Check for file opening errors, if there were any, exit
if (!dvarList)
return false;
// Get the input file size
fseek(dvarList, 0, SEEK_END);
long fileSize = ftell(dvarList);
fseek(dvarList, 0, SEEK_SET);
// Allocate memory
DvarFileMemory = (char *)VirtualAlloc(nullptr, fileSize, MEM_COMMIT, PAGE_READWRITE);
if (!DvarFileMemory)
return false;
// Read the file
fread_s(DvarFileMemory, fileSize, 1, fileSize, dvarList);
// Close it
fclose(dvarList);
return true;
}
int fileSendTcp(int socket, char *filename) {
FILE *stream; //fopen check
for(int i = 0; i < strlen(filename); i++)
{
if(filename[i] == '\n')
filename[i] = '\0';
}
if(fopen_s(&stream, adaptFileName(filename), "rb" )) {
perror("fopen error");
return -1;
}
else {
char sendline[1024] = "/sendfile "; //command to server for start receiving
strcat_s(sendline, 1024, filename);
send(socket, sendline, 1024, 0);
}
char buff[1024];
int sizeCheck = 0, fileSize;
fseek(stream,0,SEEK_END);
fileSize = ftell(stream); //filesize calc
fseek(stream,0,SEEK_SET);
printf("Filesize: %d\n", fileSize);
char fsz[1024];
_itoa_s(fileSize, fsz, 1024, 10); //send file size to server
send(socket, fsz, 1024, 0);
recv(socket, fsz, 1024, 0);
int servFileSize = atoi(fsz);
printf("Server's file size: %d\n", servFileSize);
if(servFileSize == fileSize) {
puts("File already exist on server");
fclose(stream);
return 0;
}
if(servFileSize != 0) {
sizeCheck = servFileSize;
fseek(stream, servFileSize, SEEK_SET);
}
while(sizeCheck < fileSize - 1) {
//_getch();
/*if(_kbhit()) {
_getch();
_itoa_s(sizeCheck, fsz, 1024, 10);
send(socket, fsz, 1024, MSG_OOB); //send OOB
printf("OOB sent\n");
}*/
printf(".");
int read = fread_s(buff, 1024, sizeof(bool), 1024, stream); //sending file
int sent = send(socket, buff, read, 0);
if(sent == SOCKET_ERROR) {
puts("Connection lost");
return 0;
}
sizeCheck += sent;
}
fclose(stream);
printf("done\n");
return 0;
}
t_kernel* load_kernel(char *src)
{
FILE* file;
char* line;
char** tab;
int width;
int height;
t_kernel* k;
int i;
fopen_s(&file, src, "r");
if (!file)
{
printf("can't open file\n");
return (0);
}
height = 0;
width = 0;
k = malloc(sizeof(t_kernel));
k->ddata = malloc(sizeof(double) * MAX_KERNEL_SIZE);
while (!feof(file)) {
i = -1;
char c;
line = malloc(255);
while (fread_s(&c, 1, sizeof(char), 1, file) && c != '\n')
if (c != '\r')
line[++i] = c;
line[++i] = '\0';
if (!strlen(line))
break;
tab = tmp_strsplit(line, ' ');
i = -1;
while (tab[++i])
{
k->ddata[height * width + i] = atof(tab[i]);
}
if (tab[0])
{
free(tab[0]);
tab[0] = 0;
}
if (tab)
{
// free(tab); // TODO
tab = 0;
}
free(line);
if (i)
++height;
if (!width)
width = i;
}
k->width = width;
k->height = height;
fclose(file);
return (k);
}
std::wstring SHA1_File(const std::wstring& a_filePath)
{
HCRYPTPROV hProv;
std::wstring l_result;
if(::CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET))
{
HCRYPTHASH hHash;
if(::CryptCreateHash(hProv, CALG_SHA1, NULL, 0, &hHash))
{
FILE *fInput = NULL;
if(_wfopen_s(&fInput, a_filePath.c_str(), L"rb") == 0)
{
char pbBuf[4096] = {0};
while(!feof(fInput))
{
DWORD dwRead = static_cast<DWORD>(
fread_s(pbBuf, 4096, sizeof(char), 4096, fInput));
::CryptHashData(hHash, (BYTE*)pbBuf, dwRead, 0);
}
fclose(fInput);
DWORD dwHashLen = 0;
DWORD dwHashLenSize = sizeof(DWORD);
if(::CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&dwHashLen, &dwHashLenSize, 0))
{
BYTE *pbHashBuf = new BYTE[dwHashLen];
memset(pbHashBuf, 0, dwHashLen);
if(::CryptGetHashParam(hHash, HP_HASHVAL, pbHashBuf, &dwHashLen, 0))
{
wchar_t wbHex[3] = {0};
for(DWORD i = 0; i < dwHashLen; i++)
{
swprintf_s(wbHex, 3, L"%02x", pbHashBuf[i]);
l_result += wbHex;
}
}
delete[] pbHashBuf;
}
}
::CryptDestroyHash(hHash);
}
::CryptReleaseContext(hProv, 0);
}
return l_result;
}
size_t
HostFileHandle::read(uint8_t *data,
size_t size,
size_t count)
{
decaf_check(mHandle);
decaf_check((mMode & File::Read) || (mMode & File::Update));
return fread_s(data, size * count, size, count, mHandle);
}
ReturnCode FileUtil::LowLevelFileRead(FILE* fFile, char* pcBuffer, size_t uiBufferSize, size_t uiBytesToRead, size_t &uiBytesRead)
{
//Read file content into buffer
if(uiBytesToRead > (uiBytesRead = fread_s(pcBuffer, uiBufferSize, sizeof(char), uiBytesToRead, fFile)))
return RC_ERR_GENERAL;
//Success!
return RC_OK;
}
int Sys_FileRead(int handle, void* dest, int count) {
if (handle < 0 || handle > MAX_HANDLES || dest == 0) {
return 0;
}
// This cast assumes not more than 32GB read at once
int bytesRead = (int)fread_s(dest, count, 1, count, FileHandles[handle]);
return bytesRead;
}
//SHA-1 hash function
bool __fastcall SHA1_Hash(
FILE *Input)
{
//Parameters check
if (HashFamilyID != HASH_ID_SHA1 || Input == nullptr)
{
fwprintf_s(stderr, L"Parameters error.\n");
return false;
}
//Initialization
std::shared_ptr<char> Buffer(new char[FILE_BUFFER_SIZE]()), StringBuffer(new char[FILE_BUFFER_SIZE]());
auto HashInstance = std::make_shared<SHA1_State>();
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
memset(StringBuffer.get(), 0, FILE_BUFFER_SIZE);
memset(HashInstance.get(), 0, sizeof(SHA1_State));
size_t ReadLength = 0;
//SHA-1 initialization
SHA1_Init(HashInstance.get());
//Hash process
while (!feof(Input))
{
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
ReadLength = fread_s(Buffer.get(), FILE_BUFFER_SIZE, sizeof(char), FILE_BUFFER_SIZE, Input);
if (ReadLength == 0 && errno == EINVAL)
{
fwprintf_s(stderr, L"Hash process error.\n");
return false;
}
else {
SHA1_Process(HashInstance.get(), (uint8_t *)Buffer.get(), (unsigned long)ReadLength);
}
}
//Binary to hex
memset(Buffer.get(), 0, FILE_BUFFER_SIZE);
SHA1_Done(HashInstance.get(), (uint8_t *)Buffer.get());
if (sodium_bin2hex(StringBuffer.get(), FILE_BUFFER_SIZE, (const unsigned char *)Buffer.get(), SHA1_SIZE_DIGEST) == nullptr)
{
fwprintf_s(stderr, L"Convert binary to hex error.\n");
return false;
}
else {
//Print to screen.
std::string HashResult = StringBuffer.get();
CaseConvert(true, HashResult);
for (size_t Index = 0;Index < HashResult.length();++Index)
fwprintf_s(stderr, L"%c", HashResult.c_str()[Index]);
fwprintf_s(stderr, L"\n");
}
return true;
}
//! Reads an amount of bytes from the file.
virtual int read(void* buffer, unsigned sizeToRead)
{
if (!File)
return 0;
#ifdef _WIN32 // dest buf, dest size, element size, count, file
return (int)fread_s(buffer, sizeToRead+1, 1, sizeToRead, File);
#else
return (int)fread(buffer, 1, sizeToRead, File);
#endif
}
void NtFile::ReadBuffer( ntSize length /*= READ_BUF_SIZE*/ )
{
if (length >= READ_BUF_SIZE)
{
return;
}
Crt::MemSet(m_readBuffer, sizeof(m_readBuffer));
fread_s(m_readBuffer, sizeof(m_readBuffer), sizeof(ntWchar) * length, 1, m_fp);
}
int _tmain(int argc, _TCHAR* argv[])
{
FILE* pFile=NULL;
PBYTE PEImage=NULL;
PBYTE pCodeData=NULL;
DWORD baseAddress=0;
unsigned int CodeDatSize=0;
BYTE MajorLinkerVersion=0;
PCHAR PEFileNam="..\\test.exe";
CHAR LogFileNam[MAX_PATH];
#pragma region 加载PE文件
fopen_s(&pFile,PEFileNam,"rb");
if(!pFile)
{
printf("Error:Can't open %s",PEFileNam);
return 0;
}
const unsigned int fileLen=_filelength(_fileno(pFile));
PEImage=new BYTE[fileLen];
fread_s(PEImage,fileLen,fileLen,1,pFile);
fclose(pFile);
#pragma endregion
#pragma region 解析PE文件
CPEInfo PEInfo;
if(!PEInfo.Parse(PEImage))
return 0;
pCodeData=PEInfo.GetCodeData();
CodeDatSize=PEInfo.GetCodeDataSize();
MajorLinkerVersion=PEInfo.GetMajorLinkerVersion();
baseAddress=PEInfo.GetBaseAddress();
#pragma endregion
//初始化LibScanner，其中加载对于的flb文件
if(!InitLibScanner(MajorLinkerVersion))
return 0;
#pragma region 调用反汇编引擎
strcpy_s(LogFileNam,MAX_PATH,PEFileNam);
ModifySuffix(LogFileNam,".log");
fopen_s(&pLogFile,LogFileNam,"wb");
if(!pFile)
{
printf("Error:Can't open %s\n",PEFileNam);
return 0;
}
PVDasm(pCodeData,CodeDatSize,baseAddress,pLogFile);
fclose(pLogFile);
#pragma endregion
printf("PEFile %s Analysis Succeed!\n",PEFileNam);
delete[] PEImage;
return 0;
}
void load_buffer(const char * filename, void * buffer, size_t size, size_t count) {
FILE * file;
if (fopen_s(&file, filename, "r") == 0) {
fread_s(buffer, size * count, size, count, file);
}
else {
std::cout << "Problem loading buffer\n";
}
fclose(file);
}
uint32_t MidiParser::_parseHeader(FILE* fp)
{
// Get ticksPerQuarterNote from Midi Header
uint16_t ticksPerQuarterNote;
fseek(fp, 12, SEEK_CUR);
fread_s(&ticksPerQuarterNote, 2, 2, 1, fp);
ticksPerQuarterNote = _byteswap_ushort(ticksPerQuarterNote);
// Get length of header track
uint32_t trackLen;
fseek(fp, 4, SEEK_CUR);
fread_s(&trackLen, 4, 4, 1, fp);
trackLen = _byteswap_ulong(trackLen);
// Parse header track to get tempo
uint32_t microsPerQuarterNote;
long endPos = ftell(fp) + trackLen;
while (ftell(fp) < endPos)
{
// Skip "00 FF"
fseek(fp, 2, SEEK_CUR);
// Get header command byte
uint8_t cmd;
fread_s(&cmd, 1, 1, 1, fp);
uint32_t len = _readVariableLen(fp);
if (cmd == 0x51)
{
// Tempo
uint8_t tmp[4] = { 0, 0, 0, 0 };
fread_s(&tmp[1], 3, 3, 1, fp);
microsPerQuarterNote = _byteswap_ulong(*(uint32_t *)tmp);
}
else // Skip any other commands
fseek(fp, len, SEEK_CUR);
}
return microsPerQuarterNote / ticksPerQuarterNote;
}
/// @brief 获取标签数据
bool GetLabel(IN unsigned int startIndex, IN unsigned int labelNum, OUT unsigned char* pBuffer) const
{
if (0 == m_pFile || 0 == m_labelNum)
return false;
unsigned int offset = LABEL_FILE_HEADER_SIZE + startIndex;
fseek(m_pFile, offset, SEEK_SET);
size_t count = fread_s(pBuffer, labelNum, 1, labelNum, m_pFile);
if (count != labelNum)
return false;
return true;
}
int Sys_FileRead(int handle, void* dest, int count)
{
if (handle < 0 || handle >= MAX_HANDLES) return -1;
FILE* file = FileHandles[handle];
if (file)
{
return (int) fread_s(dest, count, 1, count, file);
}
return -1;
}
void HttpTrans::recvData(const int& code, FILE* fp, const int& id, const int& reDirectCount)
{
//std::unique_lock<std::mutex> lock(lock_);
std::wstring rsp;
if ( fp )
{
fseek(fp, 0L, SEEK_END);
long length = ftell(fp);
fseek(fp, 0, SEEK_SET);
if ( length > 0 )
{
char* szBuf = new char[length+1];
memset(szBuf, 0, length + 1);
if (fread_s(szBuf, length + 1, 1, length, fp) > 0){
rsp = cyjh::UTF8ToUnicode(szBuf);
delete[]szBuf;
}
}
}
std::shared_ptr<resp_context_> parm(new resp_context_);
parm->id_ = id;
parm->errcode_ = code;
parm->head_ = " ";
parm->body_ = " ";
int i = 0;
int pos = 0;
while (i < reDirectCount)
{
pos = rsp.find(L"\r\n\r\n");
if ( pos > 0 )
{
rsp.erase(0, pos + 4);
}
++i;
}
pos = rsp.find(L"\r\n\r\n");
if ( pos > 0 )
{
std::wstring whead = rsp.substr(0, pos);
int size = rsp.size() - pos - 4;
if ( size > 0 )
{
std::wstring wbody = rsp.substr(pos + 4, size);
parm->body_ = cyjh::UnicodeToUTF8(wbody);
}
parm->head_ = cyjh::UnicodeToUTF8(whead);
}
CefPostTask(TID_UI, base::Bind(&ackData, parm));
}
//--------------------------------------------------------------------------------------------
// チャンクがOggかどうかを調べる
//--------------------------------------------------------------------------------------------
bool ovIsOgg(const std::string& filename)
{
FILE* fp = NULL;
char c[3];
fopen_s(&fp, filename.c_str(), "rb");
if(fp == NULL) return false;
fread_s(c, sizeof(c), 3, 1, fp);
fclose(fp);
return (c[0] == 'O') &&
(c[1] == 'g') &&
(c[2] == 'g');
}
/// @brief 获取图像数据
bool GetImage(IN unsigned int startIndex, IN unsigned int imageNum, OUT unsigned char* pBuffer) const
{
if (0 == m_pFile || 0 == m_imageNum || 0 == m_imageRow || 0 == m_imageCol)
return false;
unsigned int imageSize = m_imageRow * m_imageCol;
unsigned int offset = IMAGE_FILE_HEADER_SIZE + startIndex * imageSize;
fseek(m_pFile, offset, SEEK_SET);
size_t count = fread_s(pBuffer, imageSize * imageNum, imageSize, imageNum, m_pFile);
if (count != imageNum)
return false;
return true;
}
// Crée la liste chainée de shifts (1er lancement du programme)
Erreur initListeShift(Shift * * pPDebShift)
{
FILE *fichierShifts;
fopen_s(&fichierShifts, FICHIER_SHIFTS, "rb");
if (fichierShifts == NULL)
{
return FICHIER_SHIFTS_INTROUVABLE;
}
else
{
ShiftFichier shiftLu;
Shift *pShiftSauve = NULL;
Erreur codeErreur;
fread_s(&shiftLu, sizeof(ShiftFichier), sizeof(ShiftFichier), 1, fichierShifts);
while (!feof(fichierShifts))
{
// from gestion.c
codeErreur = ajoutShift(pPDebShift, &pShiftSauve, shiftLu.date, shiftLu.heure, 0, NULL);
if (codeErreur == PAS_D_ERREUR)
{
fread_s(&shiftLu, sizeof(ShiftFichier), sizeof(ShiftFichier), 1, fichierShifts);
}
else
{
return codeErreur;
}
}
fclose(fichierShifts);
return PAS_D_ERREUR;
}
}
