//-------------------------------------------------------------------------
// Desc:	Abstraction class for 64 bit files.
// Tabs:	3
//
//		Copyright (c) 2001,2003,2005-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		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, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: f64bitfh.cpp 12329 2006-01-20 17:49:30 -0700 (Fri, 20 Jan 2006) ahodgkinson $
//-------------------------------------------------------------------------

#include "flaimsys.h"

/****************************************************************************
Desc:
****************************************************************************/
F_64BitFileHandle::F_64BitFileHandle(
	FLMUINT			uiMaxFileSize)
{
	m_bOpen = FALSE;
	m_ucPath[ 0] = 0;
	m_ui64EOF = 0;
	m_pLockFileHdl = NULL;
	f_memset( m_pFileHdlList, 0, sizeof( FH_INFO) * F_64BIT_FHDL_LIST_SIZE);
	m_uiMaxFileSize = uiMaxFileSize;
	if( !m_uiMaxFileSize)
	{
		m_uiMaxFileSize = F_64BIT_FHDL_DEFAULT_MAX_FILE_SIZE;
	}
}

/****************************************************************************
Desc:
****************************************************************************/
F_64BitFileHandle::~F_64BitFileHandle()
{
	if( m_bOpen)
	{
		Close();
	}

	flmAssert( !m_pLockFileHdl);
}

/****************************************************************************
Desc:
****************************************************************************/
void F_64BitFileHandle::ReleaseLockFile(
	const char *	pszBasePath,
	FLMBOOL			bDelete)
{
#ifndef FLM_UNIX
	F_UNREFERENCED_PARM( bDelete);
	F_UNREFERENCED_PARM( pszBasePath);
#endif
	
	if( m_pLockFileHdl)
	{
		// Release the lock file

		(void)m_pLockFileHdl->Close();
		m_pLockFileHdl->Release();
		m_pLockFileHdl = NULL;

#ifdef FLM_UNIX
		if( bDelete)
		{
			char		szTmpPath[ F_PATH_MAX_SIZE];

			// Delete the lock file

			f_strcpy( szTmpPath, pszBasePath);
			f_pathAppend( szTmpPath, "64.LCK");
			gv_FlmSysData.pFileSystem->Delete( szTmpPath);
		}
#endif
	}
}
	
/****************************************************************************
Desc:	Closes all data files associated with the object
****************************************************************************/
void F_64BitFileHandle::Close(
	FLMBOOL			bDelete)
{
	RCODE				rc = FERR_OK;
	FLMUINT			uiLoop;
	F_DirHdl *		pDir = NULL;
	char				szTmpPath[ F_PATH_MAX_SIZE];

	if( !m_bOpen)
	{
		return;
	}

	for( uiLoop = 0; uiLoop < F_64BIT_FHDL_LIST_SIZE; uiLoop++)
	{
		if( m_pFileHdlList[ uiLoop].pFileHdl)
		{
			if( m_pFileHdlList[ uiLoop].bDirty)
			{
				(void)m_pFileHdlList[ uiLoop].pFileHdl->Flush();
			}
			m_pFileHdlList[ uiLoop].pFileHdl->Close();
			m_pFileHdlList[ uiLoop].pFileHdl->Release();
			f_memset( &m_pFileHdlList[ uiLoop], 0, sizeof( FH_INFO));
		}
	}

	m_ui64EOF = 0;
	m_bOpen = FALSE;

	if( bDelete)
	{
		if( RC_OK( gv_FlmSysData.pFileSystem->OpenDir(
			m_ucPath, "*.64", &pDir)))
		{
			// Remove all data files

			for( rc = pDir->Next(); !RC_BAD( rc) ; rc = pDir->Next() )
			{
				pDir->CurrentItemPath( szTmpPath);
				flmAssert( f_strstr( szTmpPath, ".64") != 0);
				(void)gv_FlmSysData.pFileSystem->Delete( szTmpPath);
			}

			pDir->Release();
			pDir = NULL;
		}

		// Release and delete the lock file

		(void)ReleaseLockFile( m_ucPath, TRUE);

		// Remove the directory

		(void)gv_FlmSysData.pFileSystem->RemoveDir( m_ucPath);
	}
	else
	{
		(void)ReleaseLockFile( m_ucPath, FALSE);
	}
}
												
/****************************************************************************
Desc:	Removes a 64-bit file
****************************************************************************/
RCODE F_64BitFileHandle::Delete(
	const char *	pszPath)
{
	RCODE				rc = FERR_OK;
	F_DirHdl *		pDir = NULL;
	char				szTmpPath[ F_PATH_MAX_SIZE];

	// Can't use this handle to delete something if we already
	// have a file open.

	if( m_bOpen)
	{
		// Can't jump to exit, because it calls ReleaseLockFile

		return( RC_SET( FERR_FAILURE));
	}

	if( RC_BAD( rc = gv_FlmSysData.pFileSystem->Exists( pszPath)))
	{
		goto Exit;
	}

	if( !gv_FlmSysData.pFileSystem->IsDir( pszPath))
	{
		// If the path specifies a single file rather than a 
		// 64-bit directory, just go ahead and delete the file.
	
		rc = gv_FlmSysData.pFileSystem->Delete( pszPath);
		goto Exit;
	}

	if( RC_BAD( rc = CreateLockFile( pszPath)))
	{
		goto Exit;
	}

	if( RC_OK( gv_FlmSysData.pFileSystem->OpenDir(
		pszPath, "*.64", &pDir)))
	{
		// Remove all data files

		for( rc = pDir->Next(); !RC_BAD( rc) ; rc = pDir->Next())
		{
			pDir->CurrentItemPath( szTmpPath);
			flmAssert( f_strstr( szTmpPath, ".64") != 0);
			(void)gv_FlmSysData.pFileSystem->Delete( szTmpPath);
		}

		pDir->Release();
		pDir = NULL;
		rc = FERR_OK;
	}

	// Release and delete the lock file

	(void)ReleaseLockFile( pszPath, TRUE);

	// Remove the directory

	(void)gv_FlmSysData.pFileSystem->RemoveDir( pszPath);

Exit:

	(void)ReleaseLockFile( pszPath, FALSE);
	return( rc);
}

/****************************************************************************
Desc:	Creates a new 64-bit "file"
****************************************************************************/
RCODE F_64BitFileHandle::Create(
	const char *	pszPath)
{
	RCODE				rc = FERR_OK;
	FLMBOOL			bCreatedDir = FALSE;

	if( m_bOpen)
	{
		rc = RC_SET( FERR_FAILURE);
		goto Exit;
	}

	if( RC_BAD( rc = gv_FlmSysData.pFileSystem->CreateDir( pszPath)))
	{
		goto Exit;
	}

	f_strcpy( m_ucPath, pszPath);
	bCreatedDir = TRUE;

	// Create the lock file

	if( RC_BAD( rc = CreateLockFile( m_ucPath)))
	{
		goto Exit;
	}

	// Initialize the EOF to 0 and set the state to open
	
	m_ui64EOF = 0;
	m_bOpen = TRUE;

Exit:

	// Release the lock file

	if( RC_BAD( rc))
	{
		(void)ReleaseLockFile( m_ucPath, TRUE);
		if( bCreatedDir)
		{
			(void)gv_FlmSysData.pFileSystem->RemoveDir( m_ucPath);
		}
	}

	return( rc);
}

/****************************************************************************
Desc:	Creates a new 64-bit file with a unique, generated name
****************************************************************************/
RCODE F_64BitFileHandle::CreateUnique(
	char *			pszPath,
	const char *	pszFileExtension)
{
	RCODE			rc = FERR_OK;
	FLMUINT		uiCount;
	FLMBOOL		bModext = TRUE;
	FLMBOOL		bCreatedDir = FALSE;
	FLMUINT		uiBaseTime = 0;
	char			ucHighByte = 0;
	char			szDirName[ F_FILENAME_SIZE];
	char			szTmpPath[ F_PATH_MAX_SIZE];
	char			szBasePath[ F_PATH_MAX_SIZE];

	if( m_bOpen)
	{
		rc = RC_SET( FERR_FAILURE);
		goto Exit;
	}

	if( !pszPath || pszPath[ 0] == '\0')
	{
#if defined( FLM_UNIX)
		f_strcpy( szBasePath, "./");
#elif defined( FLM_NLM)
		f_strcpy( szBasePath, "SYS:_NETWARE");
#else
		szBasePath[ 0] = '\0';
#endif
	}
	else
	{
		f_strcpy( szBasePath, pszPath);
	}

	if ((pszFileExtension) && (f_strlen( pszFileExtension) >= 3))
	{
		bModext = FALSE;
	}

	uiCount = 0;
	szDirName[ 0] = '\0';
	do
	{
		f_pathCreateUniqueName( &uiBaseTime, szDirName, pszFileExtension,
										&ucHighByte, bModext);

		f_strcpy( szTmpPath, szBasePath);
		f_pathAppend( szTmpPath, szDirName);
		rc = gv_FlmSysData.pFileSystem->CreateDir( szTmpPath);
	} while ((rc != FERR_OK) && (uiCount++ < 20));

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

	f_strcpy( m_ucPath, szTmpPath);
	bCreatedDir = TRUE;

	// Create the lock file

	if( RC_BAD( rc = CreateLockFile( m_ucPath)))
	{
		goto Exit;
	}

	// Initialize the EOF to 0 and set the state to open
	
	m_ui64EOF = 0;
	m_bOpen = TRUE;

Exit:

	// Release the lock file

	if( RC_BAD( rc))
	{
		ReleaseLockFile( m_ucPath, TRUE);

		if( bCreatedDir)
		{
			(void)gv_FlmSysData.pFileSystem->RemoveDir( m_ucPath);
		}
	}

	return( rc);
}
	
/****************************************************************************
Desc:	Opens an existing 64-bit file
****************************************************************************/
RCODE F_64BitFileHandle::Open(
	const char *	pszPath)
{
	RCODE				rc = FERR_OK;
	F_DirHdl *		pDir = NULL;
	FLMUINT			uiTmp;
	FLMUINT			uiHighFileNum = 0;
	FLMUINT			uiHighOffset = 0;

	if( m_bOpen)
	{
		rc = RC_SET( FERR_FAILURE);
		goto Exit;
	}

	if( RC_BAD( gv_FlmSysData.pFileSystem->Exists( pszPath)) ||
		!gv_FlmSysData.pFileSystem->IsDir( pszPath))
	{
		rc = RC_SET( FERR_IO_PATH_NOT_FOUND);
		goto Exit;
	}

	f_strcpy( m_ucPath, pszPath);

	// Create the lock file

	if( RC_BAD( rc = CreateLockFile( m_ucPath)))
	{
		goto Exit;
	}

	// Need to determine the current EOF

	if( RC_BAD( rc = gv_FlmSysData.pFileSystem->OpenDir(
		m_ucPath, "*.64", &pDir)))
	{
		goto Exit;
	}

	// Find all data files to determine the EOF

	for( rc = pDir->Next(); !RC_BAD( rc) ; rc = pDir->Next() )
	{
		if( RC_OK( GetFileNum( pDir->CurrentItemName(), &uiTmp)))
		{
			if( uiTmp >= uiHighFileNum)
			{
				uiHighFileNum = uiTmp;
				uiHighOffset = pDir->CurrentItemSize();
			}
		}
	}
	rc = FERR_OK;

	m_ui64EOF = (((FLMUINT64)uiHighFileNum) * (FLMUINT64)m_uiMaxFileSize) +	
		(FLMUINT64)uiHighOffset;
	m_bOpen = TRUE;

Exit:

	if( pDir)
	{
		pDir->Release();
	}

	// Release the lock file

	if( RC_BAD( rc))
	{
		ReleaseLockFile( m_ucPath, FALSE);
	}

	return( rc);
}

/****************************************************************************
Desc:	Flushes cached data to the data file(s)
****************************************************************************/
RCODE F_64BitFileHandle::Flush( void)
{
	RCODE			rc = FERR_OK;
	FLMUINT		uiLoop;

	if( !m_bOpen)
	{
		rc = RC_SET( FERR_FAILURE);
		goto Exit;
	}

	for( uiLoop = 0; uiLoop < F_64BIT_FHDL_LIST_SIZE; uiLoop++)
	{
		if( m_pFileHdlList[ uiLoop].bDirty)
		{
			if( RC_BAD( rc = m_pFileHdlList[ uiLoop].pFileHdl->Flush()))
			{
				goto Exit;
			}
			m_pFileHdlList[ uiLoop].bDirty = FALSE;
		}
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:	Reads data from the file
****************************************************************************/
RCODE F_64BitFileHandle::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 = FERR_OK;
	FLMUINT			uiFileNum = GetFileNum( ui64Offset);
	FLMUINT			uiFileOffset = GetFileOffset( ui64Offset);
	FLMUINT			uiTmp;
	FLMUINT			uiTotalBytesRead = 0;
	FLMUINT			uiBytesToRead;
	FLMUINT			uiMaxReadLen;
	F_FileHdl *		pFileHdl;

	// Handle the case of a 0-byte read

	if( !uiLength)
	{
		if( ui64Offset >= m_ui64EOF)
		{
			rc = RC_SET( FERR_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( FERR_IO_END_OF_FILE);
			goto Exit;
		}

		uiMaxReadLen = m_uiMaxFileSize - uiFileOffset;
		flmAssert( 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 == FERR_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 = FERR_OK;
			}
			else
			{
				goto Exit;
			}
		}
		else
		{
			if( RC_BAD( rc = pFileHdl->Read( uiFileOffset, uiBytesToRead, 
				pvBuffer, &uiTmp)))
			{
				if( rc == FERR_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 = FERR_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);
}

/****************************************************************************
Desc:	Writes data to the file
****************************************************************************/
RCODE F_64BitFileHandle::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 = FERR_OK;
	FLMUINT			uiFileNum = GetFileNum( ui64Offset);
	FLMUINT			uiFileOffset = GetFileOffset( ui64Offset);
	FLMUINT			uiTmp;
	FLMUINT			uiTotalBytesWritten = 0;
	FLMUINT			uiBytesToWrite;
	FLMUINT			uiMaxWriteLen;
	F_FileHdl *		pFileHdl;

	// Don't allow zero-length writes

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

/****************************************************************************
Desc:	Returns the requested file handle
****************************************************************************/
RCODE F_64BitFileHandle::GetFileHdl(
	FLMUINT			uiFileNum,
	FLMBOOL			bGetForWrite,
	F_FileHdl **	ppFileHdl)
{
	RCODE				rc = FERR_OK;
	FLMUINT			uiSlot;
	F_FileHdl *		pTmpHdl;
	char				ucPath[ F_PATH_MAX_SIZE];

	flmAssert( m_bOpen);

	*ppFileHdl = NULL;

	uiSlot = uiFileNum % F_64BIT_FHDL_LIST_SIZE;
	pTmpHdl = m_pFileHdlList[ uiSlot].pFileHdl;

	if( pTmpHdl && m_pFileHdlList[ uiSlot].uiFileNum != uiFileNum)
	{
		if( RC_BAD( rc = pTmpHdl->Flush()))
		{
			goto Exit;
		}

		pTmpHdl->Close();
		pTmpHdl->Release();
		pTmpHdl = NULL;

		f_memset( &m_pFileHdlList[ uiSlot], 0, sizeof( FH_INFO));
	}
	
	if( !pTmpHdl)
	{
		DataFilePath( uiFileNum, ucPath);
		if( RC_BAD( rc = gv_FlmSysData.pFileSystem->Open( ucPath, F_IO_RDWR,
			&pTmpHdl)))
		{
			if( rc == FERR_IO_PATH_NOT_FOUND && bGetForWrite)
			{
				if( RC_BAD( rc = gv_FlmSysData.pFileSystem->Create( ucPath,
 					F_IO_RDWR | F_IO_EXCL, &pTmpHdl)))
				{
					goto Exit;
				}
			}
			else
			{
				goto Exit;
			}
		}

		m_pFileHdlList[ uiSlot].pFileHdl = pTmpHdl;
		m_pFileHdlList[ uiSlot].uiFileNum = uiFileNum;
		flmAssert( !m_pFileHdlList[ uiSlot].bDirty);
	}

	*ppFileHdl = m_pFileHdlList[ uiSlot].pFileHdl;
	if( bGetForWrite)
	{
		m_pFileHdlList[ uiSlot].bDirty = TRUE;
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:	Given a data file name, returns the file's number
****************************************************************************/
RCODE F_64BitFileHandle::GetFileNum(
	const char *		pucFileName,
	FLMUINT *			puiFileNum)
{
	RCODE			rc = FERR_OK;
	FLMUINT		uiCnt = 0;
	FLMUINT		uiDigit;
	FLMUINT		uiFileNum = 0;

	if( f_strlen( pucFileName) != 11) // XXXXXXXX.64
	{
		rc = RC_SET( FERR_IO_INVALID_PATH);
		goto Exit;
	}

	if( f_strcmp( &pucFileName[ 8], ".64") != 0)
	{
		rc = RC_SET( FERR_IO_INVALID_PATH);
		goto Exit;
	}

	while( uiCnt < 8)
	{
		uiDigit = pucFileName[ uiCnt];
		if( uiDigit >= NATIVE_LOWER_A && uiDigit <= NATIVE_LOWER_F)
		{
			uiDigit = (FLMUINT)(uiDigit - NATIVE_LOWER_A) + 10;
		}
		else if( uiDigit >= NATIVE_UPPER_A && uiDigit <= NATIVE_UPPER_F)
		{
			uiDigit = (FLMUINT)(uiDigit - NATIVE_UPPER_A) + 10;
		}
		else if( uiDigit >= NATIVE_ZERO && uiDigit <= NATIVE_NINE)
		{
			uiDigit -= NATIVE_ZERO;
		}
		else
		{
			// Invalid character found in the file name

			rc = RC_SET( FERR_IO_INVALID_PATH);
			goto Exit;
		}

		uiFileNum <<= 4;
		uiFileNum += uiDigit;
		uiCnt++;
	}

	*puiFileNum = uiFileNum;

Exit:

	return( rc);
}

/****************************************************************************
Desc:	This routine obtains exclusive access to a 64-bit file by creating
		a .lck file.  The object holds the .lck file open as long as the
		64-bit file is open.
****************************************************************************/
RCODE F_64BitFileHandle::CreateLockFile(
	const char *		pszBasePath)
{
	RCODE					rc = FERR_OK;
	char					szLockPath [F_PATH_MAX_SIZE];
	F_FileHdlImp *		pLockFileHdl = NULL;

	f_strcpy( szLockPath, pszBasePath);
	f_pathAppend( szLockPath, "64.LCK");

	// Attempt to create the lock file.  If it fails, the lock file
	// may have been left because of a crash.  Hence, we first try
	// to delete the file.  If that succeeds, we then attempt to
	// create the file again.  If it, or the 2nd create fail, we simply 
	// return an access denied error.

#ifndef FLM_UNIX
	if( RC_BAD( gv_FlmSysData.pFileSystem->Create( szLockPath,
		F_IO_RDWR | F_IO_EXCL | F_IO_SH_DENYRW | F_IO_DELETE_ON_CLOSE,
		(F_FileHdl **)&pLockFileHdl)))
	{
		if( RC_BAD( gv_FlmSysData.pFileSystem->Delete( szLockPath)))
		{
			rc = RC_SET( FERR_IO_ACCESS_DENIED);
			goto Exit;
		}
		else if (RC_BAD( gv_FlmSysData.pFileSystem->Create( szLockPath,
			F_IO_RDWR | F_IO_EXCL | F_IO_SH_DENYRW | F_IO_DELETE_ON_CLOSE, 
			(F_FileHdl **)&pLockFileHdl)))
		{
			rc = RC_SET( FERR_IO_ACCESS_DENIED);
			goto Exit;
		}
	}
#else
	if( RC_BAD( gv_FlmSysData.pFileSystem->Create( szLockPath,
		F_IO_RDWR | F_IO_EXCL | F_IO_SH_DENYRW,
		(F_FileHdl **)&pLockFileHdl)))
	{
		if( RC_BAD( gv_FlmSysData.pFileSystem->Open( szLockPath,
			F_IO_RDWR | F_IO_SH_DENYRW,
			(F_FileHdl **)&pLockFileHdl)))
		{
			rc = RC_SET( FERR_IO_ACCESS_DENIED);
			goto Exit;
		}
	}

	if( RC_BAD( pLockFileHdl->Lock()))
	{
		rc = RC_SET( FERR_IO_ACCESS_DENIED);
		goto Exit;
	}
#endif

	m_pLockFileHdl = pLockFileHdl;
	pLockFileHdl = NULL;

Exit:

	if (pLockFileHdl)
	{
		(void)pLockFileHdl->Close();
		pLockFileHdl->Release();
		pLockFileHdl = NULL;
	}
	return( rc);
}