Index: modules/App Framework/FileEx.cpp
===================================================================
diff -u -N
--- modules/App Framework/FileEx.cpp	(revision 5d5f6e5b4a377c3b01a0ef17ad079770319f30ff)
+++ modules/App Framework/FileEx.cpp	(revision 0)
@@ -1,917 +0,0 @@
-/************************************************************************
-	Copy Handler 1.x - program for copying data in Microsoft Windows
-						 systems.
-	Copyright (C) 2001-2003 Ixen Gerthannes (ixen@interia.pl)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; either version 2 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*************************************************************************/
-
-#include "stdafx.h"
-#include "FileEx.h"
-#include "crc32.h"
-#ifndef DISABLE_CRYPT
-#include "crypt.h"
-#endif
-
-#ifdef _DEBUG
-#define new DEBUG_NEW
-#endif
-
-#pragma warning( disable : 4127 )
-
-// serialization buffer add on every reallocation
-#define SERIALBUFFER_DELTA	4096UL
-
-///////////////////////////////////////////////////////////////
-// Opens file
-// pszFilename [in] - name of the file to open
-// dwAccess [in] - type of access to this file (R, W, RW, APPEND)
-// dwBufferSize [in] - size of internal buffer when using buffered
-//						operations.
-///////////////////////////////////////////////////////////////
-void CFileEx::Open(PCTSTR pszFilename, DWORD dwAccess, DWORD dwBufferSize)
-{
-	// check if this object is ready to open a file
-	if (m_hFile)
-		Close();
-
-	HANDLE hFile=NULL;
-	switch (dwAccess & FA_OPERATION)
-	{
-	case FA_READ:
-		hFile=CreateFile(pszFilename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-		break;
-	case FA_WRITE:
-		hFile=CreateFile(pszFilename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-		break;
-	case FA_RW:
-	case FA_APPEND:
-		hFile=CreateFile(pszFilename, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-		break;
-	default:
-		_ASSERT(false);		// unknown File access value
-	}
-
-	// check if operation succeeded
-	if (hFile == INVALID_HANDLE_VALUE)
-		THROW_FILEEXCEPTIONEX(_T("Cannot open the specified file (CreateFile failed)."), pszFilename, FERR_OPEN, GetLastError());
-	else
-	{
-		// store hFile
-		m_hFile=hFile;
-
-		// remember path of this file
-		m_pszFilename=new TCHAR[_tcslen(pszFilename)+1];
-		_tcscpy(m_pszFilename, pszFilename);
-
-		// remember the mode
-		m_dwMode=dwAccess;
-
-		// is this buffered ?
-        SetBuffering((dwAccess & 0x8000) != 0, dwBufferSize);
-	}
-
-	// if this is the "FA_APPEND" access mode - seek to end
-	if ((dwAccess & FA_OPERATION) == FA_APPEND)
-		InternalSeek(0, FILE_END);
-}
-
-///////////////////////////////////////////////////////////////
-// Closes the file (could be used on non-opened files
-///////////////////////////////////////////////////////////////
-void CFileEx::Close()
-{
-	// only if the file has been opened
-	if (m_hFile)
-	{
-		// flush all data
-		Flush();
-
-		// close da file
-		if (!CloseHandle(m_hFile))
-		{
-			// error closing
-			THROW_FILEEXCEPTIONEX(_T("Cannot close the handle associated with a file (CloseHandle failed)."), m_pszFilename, FERR_CLOSE, GetLastError());
-		}
-		else
-			m_hFile=NULL;
-
-		// free strings and other data
-		delete [] m_pszFilename;
-		m_pszFilename=NULL;
-		delete [] m_pbyBuffer;
-		m_pbyBuffer=NULL;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Flushes internal buffers when using buffered operations
-// may be used in non-buffered mode and for not opened files
-// sets file pointer to the place resulting from position
-// in internal buffer
-///////////////////////////////////////////////////////////////
-void CFileEx::Flush()
-{
-	if (m_hFile && m_bBuffered && m_dwDataCount > 0)
-	{
-		if (m_bLastOperation)
-		{
-			// last operation - storing data
-			WritePacket();
-		}
-		else
-		{
-			// last - reading data
-			// set file pointer to position current-(m_dwDataCount-m_dwCurrentPos)
-			InternalSeek(-(long)(m_dwDataCount-m_dwCurrentPos), FILE_CURRENT);
-			m_dwCurrentPos=0;
-			m_dwDataCount=0;
-		}
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Reads some data from file (buffered or not)
-// pBuffer [in/out] - buffer for data
-// dwSize [in] - size of data to read
-// Ret Value [out] - count of bytes read (could differ from
-//						dwSize)
-///////////////////////////////////////////////////////////////
-DWORD CFileEx::ReadBuffer(void* pBuffer, DWORD dwSize)
-{
-	_ASSERT(m_hFile);		// forgot to open the file ?
-
-	// flush if needed
-	if (m_bLastOperation)
-	{
-		Flush();
-		m_bLastOperation=false;
-	}
-
-	if (!m_bBuffered)
-	{
-		// unbuffered operation (read what is needed)
-		DWORD dwRD=0;
-		if (!ReadFile(m_hFile, pBuffer, dwSize, &dwRD, NULL))
-			THROW_FILEEXCEPTIONEX(_T("Cannot read data from file (ReadFile failed)."), m_pszFilename, FERR_READ, GetLastError());
-
-		return dwRD;		// if 0 - eof (not treated as exception)
-	}
-	else
-	{
-		// reads must be done by packets
-		DWORD dwCurrPos=0;			// position in external buffer
-        while (dwCurrPos<dwSize)
-		{
-			// is there any data left ?
-			if (m_dwDataCount == 0 || m_dwCurrentPos == m_dwDataCount)
-			{
-				if (ReadPacket() == 0)
-					return dwCurrPos;				// return what was read 'til now
-			}
-
-			// copy data into external buffer
-			DWORD dwCount=__min(m_dwDataCount-m_dwCurrentPos, dwSize-dwCurrPos);
-			memcpy(((BYTE*)pBuffer)+dwCurrPos, m_pbyBuffer+m_dwCurrentPos, dwCount);
-
-			// update positions
-            dwCurrPos+=dwCount;
-			m_dwCurrentPos+=dwCount;
-		}
-
-		return dwCurrPos;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Writes data to file (buffered or not)
-// pBuffer [in/out] - buffer for data
-// dwSize [in] - count of data to read
-// Ret Value [out] - count of bytes written
-///////////////////////////////////////////////////////////////
-DWORD CFileEx::WriteBuffer(void* pBuffer, DWORD dwSize)
-{
-	_ASSERT(m_hFile);
-
-	if (!m_bLastOperation)
-	{
-		Flush();
-		m_bLastOperation=true;
-	}
-
-	if (!m_bBuffered)
-	{
-		// standard write
-		DWORD dwWR=0;
-		if (!WriteFile(m_hFile, pBuffer, dwSize, &dwWR, NULL))
-			THROW_FILEEXCEPTIONEX(_T("Cannot write data to a file (WriteFile failed)."), m_pszFilename, FERR_WRITE, GetLastError());
-		return dwWR;
-	}
-	else
-	{
-		DWORD dwPos=0;
-
-		while (dwPos<dwSize)
-		{
-			// check if buffer need storing
-			if (m_dwCurrentPos == m_dwBufferSize)
-				WritePacket();
-
-			// now add to internal buffer some data
-			DWORD dwCount=__min(m_dwBufferSize-m_dwCurrentPos, dwSize-dwPos);
-
-			memcpy(m_pbyBuffer+m_dwCurrentPos, ((BYTE*)pBuffer)+dwPos, dwCount);
-
-			// update
-			m_dwCurrentPos+=dwCount;
-			m_dwDataCount+=dwCount;
-			dwPos+=dwCount;
-		}
-
-		return dwPos;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Reads one line of text from text file (buffered). When mode
-// is unbuffered - for this operation it's switched for
-// buffered one, and then switched again after finished.
-// pszStr [in/out] - buffer for data
-// dwMaxLen [in] - max size of the buffer
-// Ret Value [out] - if the line of text was successfully read
-///////////////////////////////////////////////////////////////
-bool CFileEx::ReadLine(TCHAR* pszStr, DWORD dwMaxLen)
-{
-	// for unbuffered operations enable buffering for this op
-	if (m_bBuffered)
-		return InternalReadString(pszStr, dwMaxLen);
-	else
-	{
-		DWORD dwSize=m_dwBufferSize;
-		SetBuffering(true, 4096);
-
-		bool bRet=InternalReadString(pszStr, dwMaxLen);
-
-		SetBuffering(false, dwSize);
-		return bRet;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Writes string (line of text) into text file
-// pszString [in] - line of text to be written
-///////////////////////////////////////////////////////////////
-void CFileEx::WriteLine(TCHAR* pszString)
-{
-	_ASSERT(m_hFile);
-
-	if (!m_bLastOperation)
-	{
-		Flush();
-		m_bLastOperation=true;
-	}
-
-	// make new string with \r\n at the end - cannot use old buffer - unknown size
-	DWORD dwLen=(DWORD)_tcslen(pszString);
-
-	TCHAR *pszData=new TCHAR[dwLen+3];
-	_tcscpy(pszData, pszString);
-	pszData[dwLen]=_T('\r');
-	pszData[dwLen+1]=_T('\n');
-	pszData[dwLen+2]=_T('\0');
-
-	try
-	{
-		if (m_bBuffered)
-		{
-			DWORD dwStrPos=0;	// current index in pszString
-			DWORD dwMin=0;		// helper
-			DWORD dwSize=dwLen+2;
-
-			// processing whole string
-			while (dwStrPos < dwSize)
-			{
-				if (m_dwCurrentPos == m_dwBufferSize)
-					WritePacket();
-
-				// count of chars to be copied
-				dwMin=__min(dwSize-dwStrPos, m_dwBufferSize-m_dwCurrentPos);
-
-				// copy data from pszString into internal buffer (maybe part of it)
-				memcpy(m_pbyBuffer+m_dwCurrentPos, pszData+dwStrPos, dwMin);
-
-				// move offsets
-				m_dwCurrentPos+=dwMin;
-				m_dwDataCount+=dwMin;
-				dwStrPos+=dwMin;
-			}
-		}
-		else
-		{
-			// standard write
-			DWORD dwWR=0;
-			if (!WriteFile(m_hFile, pszData, dwLen+2, &dwWR, NULL))
-				THROW_FILEEXCEPTIONEX(_T("Cannot write data to a file (WriteFile failed)."), m_pszFilename, FERR_WRITE, GetLastError());
-		}
-	}
-	catch(...)
-	{
-		delete [] pszData;
-		throw;
-	}
-
-	delete [] pszData;
-}
-
-///////////////////////////////////////////////////////////////
-// Sets file pointer to some position (flushes buffers if
-// needed)
-// llOffset [in] - offset to move (look@ SetFilePointer in
-//					Platform SDK)
-// uiFrom [in] - type of move operation (look @ SetFilePointer
-//					in Platform SDK).
-///////////////////////////////////////////////////////////////
-void CFileEx::Seek(LONGLONG llOffset, UINT uiFrom)
-{
-	// flush buffer
-	Flush();
-
-	// seek
-	InternalSeek(llOffset, uiFrom);
-}
-
-///////////////////////////////////////////////////////////////
-// Returns current file position (physical, corrented with 
-// size and position in internal buffer if buffered mode).
-// Doesn't flush internal buffer.
-// Ret Value [out] - position in a buffer
-///////////////////////////////////////////////////////////////
-LONGLONG CFileEx::GetPos()
-{
-	// return corrected by internal members current file position
-	return InternalSeek(0, FILE_CURRENT)-m_dwDataCount+m_dwCurrentPos;
-}
-
-///////////////////////////////////////////////////////////////
-// Sets end of file at current file position (flushes internal
-// buffer before).
-///////////////////////////////////////////////////////////////
-void CFileEx::SetEndOfFile()
-{
-	_ASSERT(m_hFile);
-
-	// flush da buffers
-	Flush();
-
-	// now set the end of file
-	if (!::SetEndOfFile(m_hFile))
-		THROW_FILEEXCEPTIONEX(_T("Cannot truncate the file (SetEndOfFile failed)."), m_pszFilename, FERR_SETEOF, GetLastError());
-}
-
-///////////////////////////////////////////////////////////////
-// Returns current size of the file (flushes buffer before
-// that)
-// Ret Value [out] - current file size
-///////////////////////////////////////////////////////////////
-LONGLONG CFileEx::GetSize()
-{
-	Flush();
-
-	ULARGE_INTEGER li;
-	li.LowPart=GetFileSize(m_hFile, &li.HighPart);
-	if (li.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
-		THROW_FILEEXCEPTIONEX(_T("Cannot get the size of the file (GetFileSize failed)."), m_pszFilename, FERR_GETSIZE, GetLastError());
-
-	return li.QuadPart;
-}
-
-///////////////////////////////////////////////////////////////
-// Sets buffered operation status and/or internal buffer size
-// (could be used on the fly - each use cause buffers to flush)
-// bEnable [in] - if the buffered operations should be enabled
-// dwSize [in] - size of the internal buffer
-///////////////////////////////////////////////////////////////
-void CFileEx::SetBuffering(bool bEnable, DWORD dwSize)
-{
-	_ASSERT(dwSize > 0);	// couldn't use 0-sized internal buffer
-
-	// flush
-	Flush();
-
-	// delete old buffer
-	if (m_bBuffered && (!bEnable || dwSize != m_dwBufferSize))
-	{
-		delete [] m_pbyBuffer;
-		m_pbyBuffer=NULL;
-	}
-
-	// alloc new buffer if needed
-	if (bEnable && (!m_bBuffered || dwSize != m_dwBufferSize))
-		m_pbyBuffer=new BYTE[dwSize];
-
-	m_bBuffered=bEnable;
-	m_dwBufferSize=dwSize;
-}
-
-///////////////////////////////////////////////////////////////
-// Changes current mode to unbuffered. If already unbuffered
-// function returns doing nothing
-///////////////////////////////////////////////////////////////
-void CFileEx::SwitchToUnbuffered()
-{
-	if (!m_bBuffered)
-		return;			// it's already unbuffered - leave it as is
-	else
-	{
-		m_bRememberedState=true;				// mark that we change state to a different one
-		SetBuffering(false, m_dwBufferSize);	// do no change internal buffer size
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Changes current mode to buffered. If already buffered
-// function returns doing nothing
-///////////////////////////////////////////////////////////////
-void CFileEx::SwitchToBuffered()
-{
-	if (m_bBuffered)
-		return;			// already buffered
-	else
-	{
-		m_bRememberedState=true;
-		SetBuffering(true, m_dwBufferSize);
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// Function restores (un)buffered state previously remembered
-// with SwitchToXXX. If SwitchToXXX doesn't change the state
-// - this function also doesn't.
-///////////////////////////////////////////////////////////////
-void CFileEx::RestoreState()
-{
-	// restore state only if changed
-	if (m_bRememberedState)
-	{
-		SetBuffering(!m_bBuffered, m_dwBufferSize);
-		m_bRememberedState=false;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-// (Internal) Reads next packet of data from file (when using
-// buffered operations it cause next data of size of internal
-// buffer to be read from file
-// Ret Value [out] - Count of data that was read
-///////////////////////////////////////////////////////////////
-DWORD CFileEx::ReadPacket()
-{
-	_ASSERT(m_hFile);
-
-	// read data
-	DWORD dwRD=0;
-	if (!ReadFile(m_hFile, m_pbyBuffer, m_dwBufferSize, &dwRD, NULL))
-		THROW_FILEEXCEPTIONEX(_T("Cannot read data from a file (ReadFile failed)."), m_pszFilename, FERR_READ, GetLastError());
-
-	// reset internal members
-	m_dwDataCount=dwRD;
-	m_dwCurrentPos=0;
-
-	return dwRD;
-}
-
-///////////////////////////////////////////////////////////////
-// (Internal) Function writes all data from internal buffer to
-// a file.
-// Ret Value [out] - count of bytes written
-///////////////////////////////////////////////////////////////
-DWORD CFileEx::WritePacket()
-{
-	_ASSERT(m_hFile);
-
-	DWORD dwWR=0;
-	if (!WriteFile(m_hFile, m_pbyBuffer, m_dwDataCount, &dwWR, NULL))
-		THROW_FILEEXCEPTIONEX(_T("Cannot write data to a file (WriteFile failed)."), m_pszFilename, FERR_WRITE, GetLastError());
-
-	// reset internal members
-	m_dwDataCount=0;
-	m_dwCurrentPos=0;
-
-	return dwWR;
-}
-
-#ifndef DISABLE_CRYPT
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::SetPassword(PCTSTR pszPass)
-{
-	// delete the old password
-	if (m_pszPassword)
-		delete [] m_pszPassword;		// delete old password
-
-	// generate the SHA256 from this password
-	m_pszPassword=new TCHAR[64+1];
-	StringToKey256(pszPass, m_pszPassword);
-}
-
-#endif
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::BeginDataBlock(DWORD dwFlags)
-{
-	// do not call begin data block within another data block
-	_ASSERT(!m_bSerializing && m_pbySerialBuffer == NULL);
-
-	// alloc the new buffer and insert there a header (a few bytes)
-	m_pbySerialBuffer=new BYTE[SERIALBUFFER_DELTA];
-	m_dwSerialBufferSize=SERIALBUFFER_DELTA;
-
-	// determine action from read or write flag
-	bool bWrite=false;
-	switch(m_dwMode & FA_OPERATION)
-	{
-	case FA_READ:
-		bWrite=false;
-		break;
-	case FA_WRITE:
-		bWrite=true;
-		break;
-	case FA_RW:
-	case FA_APPEND:
-		_ASSERT(FALSE);		// cannot use serialization with files opened in rw mode
-		break;
-	}
-
-	// action
-	if (bWrite)
-	{
-		// reserve some space for a header
-		m_dwSerialBufferPos=sizeof(SERIALIZEINFOHEADER);
-	}
-	else
-	{
-		// we need to read the block from a file
-		if (ReadBuffer(m_pbySerialBuffer, sizeof(SERIALIZEINFOHEADER)) != sizeof(SERIALIZEINFOHEADER))
-		{
-			ClearSerialization();
-			THROW_FILEEXCEPTIONEX(_T("Cannot read the specified amount of data from a file (reading serialization header)."), m_pszFilename, FERR_SERIALIZE, GetLastError());
-		}
-
-		// move forward
-		m_dwSerialBufferPos=sizeof(SERIALIZEINFOHEADER);
-
-		// determine the size of the remaining data in file
-		SERIALIZEINFOHEADER* psih=(SERIALIZEINFOHEADER*)m_pbySerialBuffer;
-		DWORD dwSize=psih->dwToRead-sizeof(SERIALIZEINFOHEADER);
-
-		// check the header crc
-		DWORD dwhc=icpf::crc32(m_pbySerialBuffer, sizeof(SERIALIZEINFOHEADER)-sizeof(DWORD));
-		if (dwhc != psih->dwHeaderCRC32)
-		{
-			ClearSerialization();
-			THROW_FILEEXCEPTIONEX(_T("Block corrupted. Header CRC check failed."), m_pszFilename, FERR_SERIALIZE, 0);
-		}
-
-		// resize the buffer
-		ResizeSerialBuffer(psih->dwToRead);
-
-		// refresh the psih
-		psih=(SERIALIZEINFOHEADER*)m_pbySerialBuffer;
-
-		// read the remaining data
-		if (ReadBuffer(m_pbySerialBuffer+m_dwSerialBufferPos, dwSize) != dwSize)
-		{
-			ClearSerialization();
-			THROW_FILEEXCEPTIONEX(_T("Cannot read specified amount of data from file (reading the after-header data)."), m_pszFilename, FERR_SERIALIZE, GetLastError());
-		}
-
-#ifndef DISABLE_CRYPT
-		// decrypt the data
-		if (dwFlags & BF_ENCRYPTED)
-		{
-			if (AES256Decrypt(m_pbySerialBuffer+m_dwSerialBufferPos, dwSize, m_pszPassword, m_pbySerialBuffer+m_dwSerialBufferPos) < 0)
-			{
-				ClearSerialization();
-				THROW_FILEEXCEPTIONEX(_T("Cannot decrypt the data read from the serialization file."), m_pszFilename, FERR_CRYPT, 0);
-			}
-		}
-#endif
-		// NOTE: do not update the position - we need ptr at the beginning of data
-
-		// now we are almost ready to retrieve data - only the crc check for the data
-		DWORD dwCRC=icpf::crc32(m_pbySerialBuffer+sizeof(SERIALIZEINFOHEADER), psih->dwDataSize-sizeof(SERIALIZEINFOHEADER));
-		if (psih->dwCRC32 != dwCRC)
-		{
-			ClearSerialization();
-			THROW_FILEEXCEPTIONEX(_T("CRC check of the data read from file failed."), m_pszFilename, FERR_SERIALIZE, GetLastError());
-		}
-	}
-
-	// make a mark
-	m_dwDataBlockFlags=dwFlags;
-	m_bSerializing=true;
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::EndDataBlock()
-{
-	// make sure everything is ok
-	_ASSERT(m_bSerializing && m_pbySerialBuffer != NULL);
-
-	// type of operation
-	bool bWrite=false;
-	switch(m_dwMode & FA_OPERATION)
-	{
-	case FA_READ:
-		bWrite=false;
-		break;
-	case FA_WRITE:
-		bWrite=true;
-		break;
-	case FA_RW:
-	case FA_APPEND:
-		_ASSERT(FALSE);		// cannot use serialization with files opened in rw mode
-		break;
-	}
-
-	// when writing - make a header, ...; when reading - do nothing important
-	if (bWrite)
-	{
-		// check if there is any data
-		if (m_dwSerialBufferPos == sizeof(SERIALIZEINFOHEADER))
-			return;												// no data has been serialized
-
-		// fill the header (real data information)
-		SERIALIZEINFOHEADER *psih=(SERIALIZEINFOHEADER*)m_pbySerialBuffer;
-		psih->dwDataSize=m_dwSerialBufferPos;
-		psih->dwCRC32=icpf::crc32(m_pbySerialBuffer+sizeof(SERIALIZEINFOHEADER), m_dwSerialBufferPos-sizeof(SERIALIZEINFOHEADER));
-
-#ifndef DISABLE_CRYPT
-		// we could encrypt the data here if needed
-		if (m_dwDataBlockFlags & BF_ENCRYPTED)
-		{
-			int iRes=AES256Crypt(m_pbySerialBuffer+sizeof(SERIALIZEINFOHEADER), m_dwSerialBufferPos-sizeof(SERIALIZEINFOHEADER), m_pszPassword, m_pbySerialBuffer+sizeof(SERIALIZEINFOHEADER));
-			if (iRes < 0)
-			{
-				ClearSerialization();
-				THROW_FILEEXCEPTIONEX(_T("Cannot encrypt the data to store."), m_pszFilename, FERR_CRYPT, 0);
-			}
-
-			// fill the header
-			psih->dwToRead=iRes+sizeof(SERIALIZEINFOHEADER);
-		}
-		else
-		{
-#endif
-			// the rest of header
-			psih->dwToRead=m_dwSerialBufferPos;
-#ifndef DISABLE_CRYPT
-		}
-#endif
-
-		// calc the header crc
-		psih->dwHeaderCRC32=icpf::crc32(m_pbySerialBuffer, sizeof(SERIALIZEINFOHEADER)-sizeof(DWORD));
-
-		// write the buffer
-		WriteBuffer(m_pbySerialBuffer, psih->dwToRead);
-	}
-
-	// remove all the traces of serializing
-	ClearSerialization();
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::SWrite(void* pData, DWORD dwSize)
-{
-	InternalAppendSerialBuffer(pData, dwSize);
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::SRead(void* pData, DWORD dwSize)
-{
-	InternalReadSerialBuffer(pData, dwSize);
-}
-
-#ifdef _MFC_VER
-
-CFileEx& CFileEx::operator<<(CString strData)
-{
-	DWORD dwLen=strData.GetLength();
-	SWrite(&dwLen, sizeof(DWORD));
-	SWrite(strData.GetBuffer(1), dwLen);
-	strData.ReleaseBuffer();
-	return *this;
-}
-	
-CFileEx& CFileEx::operator>>(CString& strData)
-{
-	DWORD dwLen;
-	SRead(&dwLen, sizeof(DWORD));
-	PTSTR pszData=strData.GetBuffer(dwLen+1);
-	try
-	{
-		SRead(pszData, dwLen);
-	}
-	catch(...)
-	{
-		pszData[dwLen]=_T('\0');
-		strData.ReleaseBuffer();
-		throw;
-	}
-
-	pszData[dwLen]=_T('\0');
-	strData.ReleaseBuffer();
-	return *this;
-}
-
-#endif
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::ClearSerialization()
-{
-	// remove all the traces of serializing
-    delete [] m_pbySerialBuffer;
-	m_pbySerialBuffer=NULL;
-	m_dwSerialBufferSize=0;
-	m_dwSerialBufferPos=0;
-	m_bSerializing=false;
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::InternalReadSerialBuffer(void* pData, DWORD dwLen)
-{
-	// check if we are reading
-	_ASSERT((m_dwMode & FA_OPERATION) == FA_READ);
-
-	// check the ranges
-	if (m_dwSerialBufferPos+dwLen > m_dwSerialBufferSize)
-	{
-		// throw an exception - read beyond the data range in a given object
-		THROW_FILEEXCEPTIONEX(_T("Trying to read the serialization data beyond the range."), m_pszFilename, FERR_MEMORY, GetLastError());
-	}
-
-	// read the data
-	memcpy(pData, m_pbySerialBuffer+m_dwSerialBufferPos, dwLen);
-	m_dwSerialBufferPos+=dwLen;
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::InternalAppendSerialBuffer(void* pData, DWORD dwCount)
-{
-	// check if we are writing
-	_ASSERT((m_dwMode & FA_OPERATION) == FA_WRITE);
-
-	// check serial buffer size (if there is enough room for the data)
-	if (m_dwSerialBufferPos+dwCount > m_dwSerialBufferSize)
-	{
-		// we need a buffer reallocation
-		DWORD dwDelta=((dwCount/SERIALBUFFER_DELTA)+1)*SERIALBUFFER_DELTA;
-
-		// alloc the new buffer
-		ResizeSerialBuffer(m_dwSerialBufferSize+dwDelta);
-	}
-
-	// real storage of the data
-	if (dwCount > 0)
-	{
-		memcpy(m_pbySerialBuffer+m_dwSerialBufferPos, pData, dwCount);
-		m_dwSerialBufferPos+=dwCount;
-	}
-}
-
-///////////////////////////////////////////////////////////////
-//
-///////////////////////////////////////////////////////////////
-void CFileEx::ResizeSerialBuffer(DWORD dwNewLen)
-{
-	// alloc the new buffer
-	BYTE* pbyNewBuffer=new BYTE[dwNewLen];
-
-	// copy the old data into the new one
-	DWORD dwCount=min(m_dwSerialBufferPos, dwNewLen);
-	if (m_dwSerialBufferPos > 0)
-		memcpy(pbyNewBuffer, m_pbySerialBuffer, dwCount);
-
-	// delete the old buffer
-	delete [] m_pbySerialBuffer;
-
-	// set the new buffer inplace and update the internal size
-	m_pbySerialBuffer=pbyNewBuffer;
-	m_dwSerialBufferSize=dwNewLen;
-}
-
-///////////////////////////////////////////////////////////////
-// (Internal) Functions reads line of text from text file
-// Only for buffered operation
-// pszStr [out] - string that was read from file
-// dwMaxLen [in] - size of the string buffer
-///////////////////////////////////////////////////////////////
-bool CFileEx::InternalReadString(TCHAR* pszStr, DWORD dwMaxLen)
-{
-	_ASSERT(m_hFile != NULL);	// file wasn't opened - error opening or you've forgotten to do so ?
-
-	// last time was writing - free buffer
-	if (m_bLastOperation)
-	{
-		Flush();
-		m_bLastOperation=false;
-	}
-
-	// zero all the string
-	memset(pszStr, 0, dwMaxLen*sizeof(TCHAR));
-
-	// additional vars
-	DWORD dwStrPos=0;			// current pos in external buffer
-	bool bSecondPass=false;		// if there is need to check data for 0x0a char
-
-	// copy each char into pszString
-	while(true)
-	{
-		// if buffer is empty - fill it
-		if (m_dwDataCount == 0 || m_dwCurrentPos == m_dwDataCount)
-		{
-			if (ReadPacket() == 0)
-				return _tcslen(pszStr) != 0;
-		}
-
-		// skipping 0x0a in second pass
-		if (bSecondPass)
-		{
-			if (m_pbyBuffer[m_dwCurrentPos] == 0x0a)
-				m_dwCurrentPos++;
-			return true;
-		}
-
-		// now process chars
-		while (m_dwCurrentPos < m_dwDataCount)
-		{
-			if (m_pbyBuffer[m_dwCurrentPos] == 0x0d)
-			{
-				bSecondPass=true;
-				m_dwCurrentPos++;
-				break;
-			}
-			else if (m_pbyBuffer[m_dwCurrentPos] == 0x0a)
-			{
-				m_dwCurrentPos++;
-				return true;
-			}
-			else
-			{
-				if (dwStrPos < dwMaxLen-1)
-					pszStr[dwStrPos++]=m_pbyBuffer[m_dwCurrentPos];
-				m_dwCurrentPos++;
-			}
-		}
-	}
-
-	return false;
-}
-
-///////////////////////////////////////////////////////////////
-// (Internal) Sets file pointer in a file
-// llOffset [in] - position to move to
-// uiFrom [in] - type of moving (see Platform SDK on
-//				SetFilePointer)
-///////////////////////////////////////////////////////////////
-LONGLONG CFileEx::InternalSeek(LONGLONG llOffset, UINT uiFrom)
-{
-	LARGE_INTEGER li;
-	li.QuadPart = llOffset;
-	li.LowPart = SetFilePointer (m_hFile, li.LowPart, &li.HighPart, uiFrom);
-
-	if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
-	{
-		// error seeking - throw an exception
-		THROW_FILEEXCEPTIONEX(_T("Seek error."), m_pszFilename, FERR_SEEK, GetLastError());
-	}
-
-	return li.QuadPart;
-}