OPENF.C

/*++ 

Copyright (c) 1995-1997 Microsoft Corporation

Module Name :

openf.c

Abstract:

This module implements a simple open file handle cache

Project:

ISAPI Extensions Sample DLL

Functions Exported:


Note:
THIS IS NOT ROBUST for REAL WORLD.
I wrote this for testing the ISAPI Async IO processing.

--*/


/************************************************************
* Include Headers
************************************************************/

# include "openf.h"


/************************************************************
* Type definitions and Globals
************************************************************/

//
// internal data structure for maintaining the list of open file handles.
//

typedef struct _OPEN_FILE {

HANDLE hFile;
struct _OPEN_FILE * pNext;
LONG nHits;
LONG nRefs;
CHAR rgchFile[MAX_PATH+1];

} OPEN_FILE, * LPOPEN_FILE;


LPOPEN_FILE g_pOpenFiles = NULL;
CRITICAL_SECTION g_csOpenFiles;
BOOL g_fIsNt = TRUE;

//
// Set up global variables containing the flags for CreateFile
// The flags can be masked for Windows 95 system
//

DWORD g_dwCreateFileShareMode =
(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE);

DWORD g_dwCreateFileFlags =
(FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED);

/************************************************************
* Functions
************************************************************/


DWORD
InitFileHandleCache(VOID)
/*++

This function initializes the file handle cache.
It should be called at the initialization time.

Arguments:
None

Returns:
Win32 error code. NO_ERROR indicates that the call succeeded.
--*/
{
OSVERSIONINFO osInfo;

InitializeCriticalSection( &g_csOpenFiles);

//
// obtain the platform type to find out how to open the file
//

osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

if ( GetVersionEx( &osInfo ) ) {
g_fIsNt = (osInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
}

if ( !g_fIsNt) {

//
// Reset the flags appropriately so that Windows 95 will be happy
//

g_dwCreateFileShareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE);
g_dwCreateFileFlags = (FILE_FLAG_SEQUENTIAL_SCAN);
}

return (NO_ERROR);

} // InitFileHandleCache()




DWORD
CleanupFileHandleCache(VOID)
{
LPOPEN_FILE pFileScan;

while ( g_pOpenFiles != NULL) {

pFileScan = g_pOpenFiles;
g_pOpenFiles = g_pOpenFiles->pNext;

if ( pFileScan->hFile != INVALID_HANDLE_VALUE) {

CloseHandle( pFileScan->hFile);
}

LocalFree( pFileScan);
}

DeleteCriticalSection( &g_csOpenFiles);

return (NO_ERROR);
} // CleanupFileHandleCache()




HANDLE
FcOpenFile(IN EXTENSION_CONTROL_BLOCK * pecb, IN LPCSTR pszFile)
/*++

FcOpenFile()

Description:
This function opens the file specified in the 'pszFile'.
If the file name starts with a '/' we use the ECB to map
the given path into a physical file path.

Arguments:
pecb - pointer to the ECB block
pszFile - pointer to file name

Returns:
valid File handle on success
--*/
{
LPOPEN_FILE pFileScan;
HANDLE hFile = INVALID_HANDLE_VALUE;

EnterCriticalSection( &g_csOpenFiles);

for ( pFileScan = g_pOpenFiles;
NULL != pFileScan;
pFileScan = pFileScan->pNext) {

if ( 0 == lstrcmpi( pFileScan->rgchFile, pszFile)) {

//
// there is a file match.
//

break;
}

} // for


if ( NULL == pFileScan) {

//
// File was not found. Create a new file handle
//

CHAR rgchFileName[ MAX_PATH]; // local copy
LPCSTR pszInputPath = pszFile;

lstrcpyn( rgchFileName, pszFile, MAX_PATH);
if ( *pszFile == '/') {

DWORD cbSize = sizeof(rgchFileName);
BOOL fRet;

// reset the file pointer, so subsequent use will fail
pszFile = NULL;

//
// Using the ECB map the Virtual path to the Physical path
//

fRet = pecb->ServerSupportFunction( pecb->ConnID,
HSE_REQ_MAP_URL_TO_PATH,
rgchFileName,
&cbSize, NULL);

if (fRet) {
// we got the mapping. Use it.
pszFile = rgchFileName;
}
}

if ( NULL != pszFile) {
pFileScan = LocalAlloc( LPTR, sizeof( *pFileScan));

if ( NULL != pFileScan) {

SECURITY_ATTRIBUTES sa;

sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = FALSE;

pFileScan->hFile =
CreateFile( pszFile,
GENERIC_READ,
g_dwCreateFileShareMode,
&sa,
OPEN_EXISTING,
g_dwCreateFileFlags,
NULL );

if ( INVALID_HANDLE_VALUE == pFileScan->hFile) {

LocalFree( pFileScan);
pFileScan = NULL;
} else {

// insert this into the list at the top
lstrcpyn( pFileScan->rgchFile, pszInputPath, MAX_PATH);
pFileScan->pNext = g_pOpenFiles;
g_pOpenFiles = pFileScan;
pFileScan->nRefs = 1;
pFileScan->nHits = 0;
}
}
}
}

if ( NULL != pFileScan) {

hFile = pFileScan->hFile;
pFileScan->nHits++;
pFileScan->nRefs++;
}

LeaveCriticalSection( &g_csOpenFiles);

return (hFile);

} // FcOpenFile()



DWORD
FcCloseFile(IN HANDLE hFile)
{
LPOPEN_FILE pFileScan;
DWORD dwError = NO_ERROR;

EnterCriticalSection( &g_csOpenFiles);

//
// Look for the handle and decrement the ref count.
//
for ( pFileScan = g_pOpenFiles;
NULL != pFileScan;
pFileScan = pFileScan->pNext) {

if ( hFile == pFileScan->hFile) {

//
// there is a file match.
//

pFileScan->nRefs--;

//
// BUGBUG: There is no freeing of the file when Ref hits '0' :(
//

break;
}

} // for


if ( NULL == pFileScan) {
//
// file handle not found
//
dwError = ( ERROR_INVALID_HANDLE);
}

LeaveCriticalSection( &g_csOpenFiles);


return ( dwError);

} // FcCloseFile()




BOOL
FcReadFromFile(
IN HANDLE hFile,
OUT CHAR * pchBuffer,
IN DWORD dwBufferSize,
OUT LPDWORD pcbRead,
IN OUT LPOVERLAPPED pov
)
/*++
Description:
Reads contents of file [hFile] from the specified offset in the overlapped
structure. The contents are read into the buffer supplied.

Arguments:
hFile - handle for the File from which to read data
pchBuffer - pointer to the buffer into which the data is to be read
dwBufferSize - DWORD containing the max size of the buffer supplied
pcbRead - number of bytes read from the file
pov - pointer to an overlapped structure that contains the
offset from where to read the contents. The
overlapped structure also is used for Overlapped
IO in NT.

Notes:
This function automatically handles both Windows 95 and NT


Returns:
TRUE on success and FALSE if there is a failure.
Use GetLastError() to get the last error code on failure.
--*/
{
BOOL fRet = TRUE;

*pcbRead = 0;

if ( !g_fIsNt ) {
//
// Windows95 does not support Overlapped IO.
// So we shall thunk it out and use Synchronous IO
//

fRet = (
SetFilePointer( hFile,
pov->Offset,
NULL,
FILE_BEGIN) &&
ReadFile( hFile,
pchBuffer,
dwBufferSize,
pcbRead,
NULL
)
);
} else {

ResetEvent( pov->hEvent);

fRet = TRUE;

// read data from file
if (!ReadFile(hFile,
pchBuffer,
dwBufferSize,
pcbRead,
pov
)) {

DWORD err = GetLastError();

if ( (err != ERROR_IO_PENDING) ||
!GetOverlappedResult( hFile, pov, pcbRead, TRUE) ) {

fRet = FALSE;
}
}
}

if ( fRet ) {
pov->Offset += *pcbRead;
}

return ( fRet );
} // FcReadFromFile()

/************************ End of File ***********************/