示例#1
0
DWORD getImportThunkRVA(FILE* f, char* dllName, char* funcName)
{
	if (strlen(dllName)==0 || strlen(funcName)==0) return 0;
	
	DWORD itSize = SeekImportTable(f);
	DWORD numDLLs = itSize / sizeof(IMAGE_IMPORT_DESCRIPTOR);
	
	for (WORD i=0; i < numDLLs; i++)
	{
		IMAGE_IMPORT_DESCRIPTOR iid;
		fread(&iid, sizeof(IMAGE_IMPORT_DESCRIPTOR), 1, f);
		DWORD fp = ftell(f);

		char iidName[256];
		fseek(f, getFileOffset(f, iid.Name), SEEK_SET);
		fread(iidName, 256, 1, f);
		
		//find the right dll
		if (stricmp(iidName, dllName) == 0) {
			// the FLT no-dvd has no OFT, but for the vitality no-dvd the FT is wrong
			if (iid.OriginalFirstThunk)
				fseek(f, getFileOffset(f, iid.OriginalFirstThunk), SEEK_SET);
			else
				fseek(f, getFileOffset(f, iid.FirstThunk), SEEK_SET);
			
			//now find the function
			for (WORD j=0;; j++)
			{
				DWORD thunkRVA;
				fread(&thunkRVA, sizeof(DWORD), 1, f);
				DWORD fp1 = ftell(f);
				if (thunkRVA==0) break;
				
				char funcName1[256];
				fseek(f, getFileOffset(f, thunkRVA) + sizeof(WORD), SEEK_SET);
				fread(funcName1, 256, 1, f);
				
				if (stricmp(funcName1, funcName) == 0) {
					return iid.FirstThunk + j*sizeof(DWORD);
				}
				
				fseek(f, fp1, SEEK_SET);
			}
		}
		
		fseek(f, fp, SEEK_SET);
	}

	return 0;
}
示例#2
0
int mtFile::runRead( mtThreadWork::DataUser* pkDataUser )
{
	char*	pcFile	= getFileName(pkDataUser->pcAccount);

	if (NULL == pcFile)
	{
		return	mtProtocol::E_RESULT_FALT_FILE_INVALIDE_PATH;
	}

	if (0 == FileOpen(&pkDataUser->hFile, pcFile))
	{
		return	mtProtocol::E_RESULT_FALT_FILE_NOT_EXIST;
	}

	pkDataUser->iFileOffset			= getFileOffset(pkDataUser->pcAccount);
	pkDataUser->ulTransferBytes		= getDataFileBytes();

	pkDataUser->kOverlapped.Offset	= pkDataUser->iFileOffset;
	pkDataUser->eOverlappedType		= mtThread::E_OLT_LOCKFILEEx;
	pkDataUser->iFileRunType		= E_FILE_RUN_READ_FILE;
	
	if (0 == FileLock(pkDataUser->hFile, pkDataUser->ulTransferBytes, &pkDataUser->kOverlapped))
	{
		FileClose(&pkDataUser->hFile);
		return	mtProtocol::E_RESULT_FALT_FILE_LOCK;
	}

	return	mtProtocol::E_RESULT_SUCCESS;
}
示例#3
0
int mtFile::completeWriteCreate( mtThreadWork::DataUser* pkDataUser )
{
	pkDataUser->iFileOffset			= getFileOffset(pkDataUser->pcAccount);
	pkDataUser->ulTransferBytes		= getDataFileBytes();
	pkDataUser->iFileRunType		= E_FILE_RUN_WRITE_FILE;

	pkDataUser->kOverlapped.Offset	= pkDataUser->iFileOffset;
	pkDataUser->eOverlappedType		= mtThread::E_OLT_LOCKFILEEx;
	if (0 == FileLock(pkDataUser->hFile, pkDataUser->ulTransferBytes, &pkDataUser->kOverlapped, LOCKFILE_EXCLUSIVE_LOCK))
	{
		FileClose(&pkDataUser->hFile);
		return	mtProtocol::E_RESULT_FALT_FILE_LOCK;
	}

	return	mtProtocol::E_RESULT_SUCCESS;

}
示例#4
0
/****************************************************************************
Desc:	This is a private method that will truncate the spill file back to
		the specified size.
****************************************************************************/
RCODE F_MultiFileHdl::truncateFile(
	FLMUINT64		ui64NewSize)
{
	RCODE				rc = NE_FLM_OK;
	FLMUINT			uiFileNum = getFileNum( ui64NewSize);
	IF_FileHdl *	pFileHdl;

	if( RC_BAD( rc = getFileHdl( uiFileNum, TRUE, &pFileHdl)))
	{
		goto Exit;
	}

	if (RC_BAD( rc = pFileHdl->truncateFile( getFileOffset( ui64NewSize))))
	{
		goto Exit;
	}

Exit:

	return( rc);
}
示例#5
0
DWORD SeekImportTable(FILE *f)
{
	DWORD itRVA=0, itSize=0;
	
	fseek(f, 0, SEEK_SET);
	IMAGE_DOS_HEADER dh;
	fread(&dh, sizeof(IMAGE_DOS_HEADER), 1, f);
	fseek(f, dh.e_lfanew - sizeof(IMAGE_DOS_HEADER), SEEK_CUR);
	IMAGE_NT_HEADERS nth;
	fread(&nth, sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER), 1, f);
	if (nth.FileHeader.SizeOfOptionalHeader > 0)
	{
		fseek(f, 104, SEEK_CUR);
		fread(&itRVA, sizeof(DWORD), 1, f);
		fread(&itSize, sizeof(DWORD), 1, f);
		fseek(f, getFileOffset(f, itRVA), SEEK_SET);

		return itSize;
	}	
	return 0;
}
示例#6
0
int mtFile::runWrite( mtThreadWork::DataUser* pkDataUser )
{
	char*	pcFile	= getFileName(pkDataUser->pcAccount);

	if (NULL == pcFile)
	{
		return	mtProtocol::E_RESULT_FALT_FILE_INVALIDE_PATH;
	}

	if (FileOpen(&pkDataUser->hFile, pcFile))
	{
 		pkDataUser->iFileOffset			= getFileOffset(pkDataUser->pcAccount);
 		pkDataUser->ulTransferBytes		= getDataFileBytes();
		pkDataUser->iFileRunType		= E_FILE_RUN_WRITE_FILE;
	}
	else 
	{
		/// ╢╢╫╗нд╪Ч
		if (FileCreate(&pkDataUser->hFile, pcFile, getFolderBytes()))
		{
			pkDataUser->iFileOffset			= 0;
			pkDataUser->ulTransferBytes		= getCreateFileBytes();
			pkDataUser->iFileRunType		= E_FILE_RUN_WRITE_FILE_CREATE;
		}
		else
		{
			return	mtProtocol::E_RESULT_FALT_FILE_CREATE_FUNCTION;
		}
	}

	pkDataUser->kOverlapped.Offset	= pkDataUser->iFileOffset;
	pkDataUser->eOverlappedType		= mtThread::E_OLT_LOCKFILEEx;
	if (0 == FileLock(pkDataUser->hFile, pkDataUser->ulTransferBytes, &pkDataUser->kOverlapped, LOCKFILE_EXCLUSIVE_LOCK))
	{
		FileClose(&pkDataUser->hFile);
		return	mtProtocol::E_RESULT_FALT_FILE_LOCK;
	}

	return	mtProtocol::E_RESULT_SUCCESS;
}
示例#7
0
// Generate a header event
bool
WriteUserLogHeader::GenerateEvent( GenericEvent &event )
{
	int len = snprintf( event.info, COUNTOF(event.info),
			  "Global JobLog:"
			  " ctime=%d"
			  " id=%s"
			  " sequence=%d"
			  " size=" FILESIZE_T_FORMAT""
			  " events=%" PRId64""
			  " offset=" FILESIZE_T_FORMAT""
			  " event_off=%" PRId64""
			  " max_rotation=%d"
			  " creator_name=<%s>",
			  (int) getCtime(),
			  getId().Value(),
			  getSequence(),
			  getSize(),
			  getNumEvents(),
			  getFileOffset(),
			  getEventOffset(),
			  getMaxRotation(),
			  getCreatorName().Value()
			  );
	if (len < 0 || len == sizeof(event.info)) {
		// not enough room in the buffer
		len = (int)COUNTOF(event.info)-1;
		event.info[len] = 0; // make sure it's null terminated.
		::dprintf( D_FULLDEBUG, "Generated (truncated) log header: '%s'\n", event.info );
	}  else {
		::dprintf( D_FULLDEBUG, "Generated log header: '%s'\n", event.info );
		while( len < 256 ) {
			event.info[len++] = ' ';
			event.info[len] = 0;
		}
	}

	return true;
}
示例#8
0
/****************************************************************************
Desc: Writes data to the file
****************************************************************************/
RCODE F_MultiFileHdl::write(
	FLMUINT64	ui64Offset,				// Offset
	FLMUINT		uiLength,				// Number of bytes to write.
	void *		pvBuffer,				// Buffer that contains bytes to be written
	FLMUINT *	puiBytesWritten)		// Number of bytes written.
{
	RCODE				rc = NE_FLM_OK;
	FLMUINT			uiFileNum = getFileNum( ui64Offset);
	FLMUINT			uiFileOffset = getFileOffset( ui64Offset);
	FLMUINT			uiTmp;
	FLMUINT			uiTotalBytesWritten = 0;
	FLMUINT			uiBytesToWrite;
	FLMUINT			uiMaxWriteLen;
	IF_FileHdl *	pFileHdl;

	// Don't allow zero-length writes

	f_assert( uiLength);

	// Write to the data file(s), moving to new files as needed.

	for( ;;)
	{
		if( RC_BAD( rc = getFileHdl( uiFileNum, TRUE, &pFileHdl)))
		{
			goto Exit;
		}

		uiMaxWriteLen = m_uiMaxFileSize - uiFileOffset;
		f_assert( uiMaxWriteLen != 0);
		uiBytesToWrite = uiLength >= uiMaxWriteLen ? uiMaxWriteLen : uiLength;

		uiTmp = 0;
		rc = pFileHdl->write( uiFileOffset, uiBytesToWrite, pvBuffer, &uiTmp);

		uiTotalBytesWritten += uiTmp;
		uiLength -= uiTmp;
		ui64Offset += uiTmp;

		if( RC_BAD( rc))
		{
			goto Exit;
		}

		if( !uiLength)
		{
			break;
		}

		// Set up for next write

		pvBuffer = ((FLMBYTE *)pvBuffer) + uiTmp;
		uiFileNum = getFileNum( ui64Offset);
		uiFileOffset = getFileOffset( ui64Offset);
	}

Exit:

	if( ui64Offset > m_ui64EOF)
	{
		m_ui64EOF = ui64Offset;
	}

	*puiBytesWritten = uiTotalBytesWritten;
	return( rc);
}
示例#9
0
/****************************************************************************
Desc: Reads data from the file
****************************************************************************/
RCODE F_MultiFileHdl::read(
	FLMUINT64	ui64Offset,				// Offset to begin reading
	FLMUINT		uiLength,				// Number of bytes to read
	void *		pvBuffer,				// Buffer
	FLMUINT *	puiBytesRead)			// [out] Number of bytes read
{
	RCODE				rc = NE_FLM_OK;
	FLMUINT			uiFileNum = getFileNum( ui64Offset);
	FLMUINT			uiFileOffset = getFileOffset( ui64Offset);
	FLMUINT			uiTmp;
	FLMUINT			uiTotalBytesRead = 0;
	FLMUINT			uiBytesToRead;
	FLMUINT			uiMaxReadLen;
	IF_FileHdl *	pFileHdl;

	// Handle the case of a 0-byte read

	if( !uiLength)
	{
		if( ui64Offset >= m_ui64EOF)
		{
			rc = RC_SET( NE_FLM_IO_END_OF_FILE);
		}
		goto Exit;
	}

	// Read the data file(s), moving to new files as needed.

	for( ;;)
	{
		if( ui64Offset >= m_ui64EOF)
		{
			rc = RC_SET( NE_FLM_IO_END_OF_FILE);
			goto Exit;
		}

		uiMaxReadLen = m_uiMaxFileSize - uiFileOffset;
		f_assert( uiMaxReadLen != 0);
		uiTmp = (uiLength >= uiMaxReadLen ? uiMaxReadLen : uiLength);
		uiBytesToRead = (((FLMUINT64)uiTmp > (FLMUINT64)(m_ui64EOF - ui64Offset))
								? (FLMUINT)(m_ui64EOF - ui64Offset)
								: uiTmp);

		if( RC_BAD( rc = getFileHdl( uiFileNum, FALSE, &pFileHdl)))
		{
			if( rc == NE_FLM_IO_PATH_NOT_FOUND)
			{
				// Handle the case of a sparse file by filling the unread
				// portion of the buffer with zeros.

				f_memset( pvBuffer, 0, uiBytesToRead);
				uiTmp = uiBytesToRead;
				rc = NE_FLM_OK;
			}
			else
			{
				goto Exit;
			}
		}
		else
		{
			if( RC_BAD( rc = pFileHdl->read( uiFileOffset, uiBytesToRead,
				pvBuffer, &uiTmp)))
			{
				if( rc == NE_FLM_IO_END_OF_FILE)
				{
					// Handle the case of a sparse file by filling the unread
					// portion of the buffer with zeros.

					f_memset( &(((FLMBYTE *)(pvBuffer))[ uiTmp]),
						0, (FLMUINT)(uiBytesToRead - uiTmp));
					uiTmp = uiBytesToRead;
					rc = NE_FLM_OK;
				}
				else
				{
					goto Exit;
				}
			}
		}

		uiTotalBytesRead += uiTmp;
		uiLength -= uiTmp;
		if( !uiLength)
		{
			break;
		}

		// Set up for next read

		pvBuffer = ((FLMBYTE *)pvBuffer) + uiTmp;
		ui64Offset += uiTmp;
		uiFileNum = getFileNum( ui64Offset);
		uiFileOffset = getFileOffset( ui64Offset);
	}

Exit:

	*puiBytesRead = uiTotalBytesRead;
	return( rc);
}
示例#10
0
void ResourceManager::pushCurrentFileAndOffsetOntoStack()
{
  fileOffsetStack[indexOfFileOffsetStack] = getFileOffset(this->fileDescriptors[this->curHandleIdx]);
  handleIndicesStack[indexOfFileOffsetStack++] = this->curHandleIdx;
}