837 lines
23 KiB
C++
837 lines
23 KiB
C++
/*++
|
||
|
||
Copyright (c) 1995 Microsoft Corporation
|
||
|
||
Module Name :
|
||
|
||
getdirp.cxx
|
||
|
||
Abstract:
|
||
This module implements the functions for getting directory listings
|
||
and transparently caching them.
|
||
( This uses OS specific functions to obtain the directory).
|
||
|
||
Author:
|
||
|
||
Murali R. Krishnan ( MuraliK ) 13-Jan-1995
|
||
|
||
Project:
|
||
|
||
Tsunami Lib
|
||
( Common caching and directory functions for Internet Services)
|
||
|
||
Functions Exported:
|
||
BOOL TsGetDirectoryListingA()
|
||
BOOL TsFreeDirectoryListing()
|
||
int __cdecl
|
||
AlphaCompareFileBothDirInfo(
|
||
IN const void * pvFileInfo1,
|
||
IN const void * pvFileInfo2)
|
||
|
||
TS_DIRECTORY_HEADER::ReadFromNtDirectoryFile(
|
||
IN LPCWSTR pwszDirectoryName
|
||
)
|
||
TS_DIRECTORY_HEADER::BuildInfoPointers(
|
||
IN LPCWSTR pwszDirectoryName
|
||
)
|
||
TS_DIRECTORY_HEADER::CleanupThis()
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
/************************************************************
|
||
* Include Headers
|
||
************************************************************/
|
||
|
||
# include "tsunamip.hxx"
|
||
|
||
# include <stdlib.h>
|
||
# include <string.h>
|
||
# include <dbgutil.h>
|
||
|
||
/************************************************************
|
||
* Type Definitions
|
||
************************************************************/
|
||
|
||
|
||
#define DIRECTORY_BUFFER_SIZE 8160 /* < 8192 bytes */
|
||
|
||
/************************************************************
|
||
* Functions
|
||
************************************************************/
|
||
|
||
|
||
BOOL FreeDirectoryHeaderContents( PVOID pvOldBlock );
|
||
|
||
|
||
dllexp
|
||
BOOL
|
||
TsGetDirectoryListing(
|
||
IN const TSVC_CACHE &tsCache,
|
||
IN PCSTR pszDirectoryName,
|
||
IN HANDLE ListingUser,
|
||
OUT PTS_DIRECTORY_HEADER * ppTsDirectoryHeader
|
||
)
|
||
/*++
|
||
This function obtains the directory listing for dir specified
|
||
in pszDirectoryName.
|
||
|
||
Arguments:
|
||
tsCache Cache structure which is used for lookup
|
||
pwszDirectoryName pointer to string containing the directory name
|
||
ListingUser Handle for the user opening the directory
|
||
ppTsDirectoryHeader
|
||
pointer to pointer to class containing directory information.
|
||
Filled on successful return. On failure this will be NULL
|
||
|
||
Returns:
|
||
TRUE on success and FALSE if there is a failure.
|
||
--*/
|
||
{
|
||
ASSERT( tsCache.IsValid() );
|
||
ASSERT( pszDirectoryName != NULL );
|
||
ASSERT( ppTsDirectoryHeader != NULL);
|
||
|
||
PVOID pvBlob = NULL;
|
||
ULONG ulSize = 0;
|
||
BOOL bSuccess;
|
||
|
||
//
|
||
// First, check to see if we have already cached a listing of this
|
||
// directory.
|
||
//
|
||
|
||
*ppTsDirectoryHeader = NULL;
|
||
bSuccess = TsCheckOutCachedBlob( tsCache,
|
||
pszDirectoryName,
|
||
RESERVED_DEMUX_DIRECTORY_LISTING,
|
||
( PVOID * )&pvBlob,
|
||
&ulSize );
|
||
|
||
if ( bSuccess )
|
||
{
|
||
ASSERT( BLOB_IS_OR_WAS_CACHED( pvBlob ) );
|
||
|
||
*ppTsDirectoryHeader = (PTS_DIRECTORY_HEADER )pvBlob;
|
||
ASSERT ( (*ppTsDirectoryHeader)->IsValid());
|
||
|
||
//
|
||
// Make sure the user tokens match
|
||
//
|
||
|
||
if ( hListingUser == (*ppTsDirectoryHeader)->QueryListingUser() )
|
||
{
|
||
IF_DEBUG( DIR_LIST) {
|
||
|
||
DBGPRINTF( (DBG_CONTEXT,
|
||
" Obtained DirectoryListing (%s) from Cache ( %08x)\n",
|
||
pszDirectoryName,
|
||
*ppTsDirectoryHeader));
|
||
|
||
(*ppTsDirectoryHeader)->Print();
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
//
|
||
// User token doesn't match, don't return it
|
||
//
|
||
|
||
bSuccess = TsCheckInCachedBlob( pvBlob );
|
||
|
||
ASSERT( bSuccess );
|
||
}
|
||
|
||
//
|
||
// The block was not present in cache.
|
||
// Obtain a fresh copy of the directory listing and cache it.
|
||
//
|
||
|
||
IF_DEBUG( DIR_LIST) {
|
||
|
||
DBGPRINTF( (DBG_CONTEXT,
|
||
"Missing DirListing (%s) in cache. Generating newly\n",
|
||
pszDirectoryName));
|
||
}
|
||
|
||
*ppTsDirectoryHeader = TsGetFreshDirectoryHeader(
|
||
tsCache,
|
||
pszDirectoryName,
|
||
hListingUser );
|
||
|
||
|
||
bSuccess = ( *ppTsDirectoryHeader != NULL);
|
||
|
||
return ( bSuccess);
|
||
|
||
} // TsGetDirectoryListing
|
||
|
||
|
||
|
||
|
||
dllexp
|
||
BOOL
|
||
TsFreeDirectoryListing(
|
||
IN const TSVC_CACHE & tsCache,
|
||
IN PTS_DIRECTORY_HEADER pDirectoryHeader
|
||
)
|
||
{
|
||
BOOL fReturn;
|
||
BOOL fCached = BLOB_IS_OR_WAS_CACHED( (PVOID ) pDirectoryHeader);
|
||
|
||
IF_DEBUG( DIR_LIST) {
|
||
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
"TsFreeDirectoryListing( %08x) called. Cached = %d\n",
|
||
pDirectoryHeader,
|
||
fCached));
|
||
|
||
pDirectoryHeader->Print();
|
||
}
|
||
|
||
if ( fCached )
|
||
{
|
||
fReturn = TsCheckInCachedBlob( ( PVOID )pDirectoryHeader );
|
||
}
|
||
else
|
||
{
|
||
fReturn = TsFree( tsCache, ( PVOID )pDirectoryHeader );
|
||
}
|
||
|
||
return( fReturn);
|
||
} // TsFreeDirectoryListing()
|
||
|
||
|
||
|
||
BOOL
|
||
FreeDirectoryHeaderContents(
|
||
PVOID pvOldBlock
|
||
)
|
||
{
|
||
PTS_DIRECTORY_HEADER pDirectoryHeader;
|
||
|
||
pDirectoryHeader = ( PTS_DIRECTORY_HEADER )pvOldBlock;
|
||
|
||
pDirectoryHeader->CleanupThis();
|
||
|
||
//
|
||
// The item may never have been added to the cache, don't
|
||
// count it in this case
|
||
//
|
||
|
||
if ( BLOB_IS_OR_WAS_CACHED( pvOldBlock ) )
|
||
{
|
||
DEC_COUNTER( BLOB_GET_SVC_ID( pvOldBlock ),
|
||
CurrentDirLists );
|
||
}
|
||
|
||
return ( TRUE);
|
||
} // FreeDirectoryHeaderContents()
|
||
|
||
|
||
|
||
|
||
int __cdecl
|
||
AlphaCompareFileBothDirInfo(
|
||
IN const void * pvFileInfo1,
|
||
IN const void * pvFileInfo2)
|
||
{
|
||
const FILE_BOTH_DIR_INFORMATION * pFileInfo1 =
|
||
*((const FILE_BOTH_DIR_INFORMATION **) pvFileInfo1);
|
||
const FILE_BOTH_DIR_INFORMATION * pFileInfo2 =
|
||
*((const FILE_BOTH_DIR_INFORMATION **) pvFileInfo2);
|
||
|
||
ASSERT( pFileInfo1 != NULL && pFileInfo2 != NULL);
|
||
|
||
return ( lstrcmp( (LPCSTR )pFileInfo1->FileName,
|
||
(LPCSTR )pFileInfo2->FileName));
|
||
|
||
} // AlphaCompareFileBothDirInfo()
|
||
|
||
|
||
|
||
BOOL
|
||
SortInPlaceFileInfoPointers(
|
||
IN OUT PFILE_BOTH_DIR_INFORMATION * prgFileInfo,
|
||
IN int nEntries,
|
||
IN PFN_CMP_FILE_BOTH_DIR_INFO pfnCompare)
|
||
/*++
|
||
This is a generic function to sort the pointers to file information
|
||
array in place using pfnCompare to compare the records for ordering.
|
||
|
||
Returns:
|
||
TRUE on success and FALSE on failure.
|
||
--*/
|
||
{
|
||
DWORD dwTime;
|
||
|
||
#ifdef INSERTION_SORT
|
||
int idxInner;
|
||
int idxOuter;
|
||
|
||
dwTime = GetTickCount();
|
||
//
|
||
// A simple insertion sort is performed. May be modified in future.
|
||
//
|
||
|
||
for( idxOuter = 1; idxOuter < nEntries; idxOuter++) {
|
||
|
||
for( idxInner = idxOuter; idxInner > 0; idxInner-- ) {
|
||
|
||
int iCmp = ( *pfnCompare)( prgFileInfo[ idxInner - 1],
|
||
prgFileInfo[ idxInner]);
|
||
|
||
if ( iCmp <= 0) {
|
||
//
|
||
// The entries in prgFileInfo[0 .. idxOuter] are in order.
|
||
// Stop bubbling the outer down.
|
||
//
|
||
break;
|
||
} else {
|
||
|
||
//
|
||
// Swap the two entries. idxInner, idxInner - 1
|
||
//
|
||
|
||
PFILE_BOTH_DIR_INFORMATION pFInfoTmp;
|
||
|
||
pFInfoTmp = prgFileInfo[ idxInner - 1];
|
||
prgFileInfo[ idxInner - 1] = prgFileInfo[idxInner];
|
||
prgFileInfo[ idxInner] = pFInfoTmp;
|
||
}
|
||
} // inner for
|
||
|
||
} // for
|
||
|
||
dwTime = GetTickCount() - dwTime;
|
||
|
||
# else
|
||
|
||
IF_DEBUG( DIR_LIST) {
|
||
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
"Qsorting the FileInfo Array %08x ( Total = %d)\n",
|
||
prgFileInfo, nEntries));
|
||
}
|
||
|
||
dwTime = GetTickCount();
|
||
qsort( (PVOID ) prgFileInfo, nEntries,
|
||
sizeof( PFILE_BOTH_DIR_INFORMATION),
|
||
pfnCompare);
|
||
|
||
dwTime = GetTickCount() - dwTime;
|
||
|
||
# endif // INSERTION_SORT
|
||
|
||
IF_DEBUG( DIR_LIST) {
|
||
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
" Time to sort %d entries = %d\n",
|
||
nEntries, dwTime));
|
||
}
|
||
|
||
return ( TRUE);
|
||
} // SortInPlaceFileInfoPointers()
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**********************************************************************
|
||
* TS_DIRECTORY_HEADER related member functions
|
||
**********************************************************************/
|
||
|
||
inline USHORT
|
||
ConvertUnicodeToAnsiInPlace(
|
||
IN OUT LPWSTR pwszUnicode,
|
||
IN USHORT usLen)
|
||
/*++
|
||
Converts given Unicode strings to Ansi In place and returns the
|
||
length of the modified string.
|
||
--*/
|
||
{
|
||
CHAR achAnsi[MAX_PATH+1];
|
||
DWORD cch;
|
||
|
||
if ( usLen > sizeof(achAnsi) )
|
||
{
|
||
ASSERT( FALSE );
|
||
*pwszUnicode = L'\0';
|
||
return 0;
|
||
}
|
||
|
||
//
|
||
// usLen is a byte count and the unicode string isn't terminated
|
||
//
|
||
|
||
cch = WideCharToMultiByte( CP_ACP,
|
||
WC_COMPOSITECHECK,
|
||
pwszUnicode,
|
||
usLen / sizeof(WCHAR),
|
||
achAnsi,
|
||
sizeof( achAnsi ),
|
||
NULL,
|
||
NULL );
|
||
|
||
if ( !cch || (cch + 1) > sizeof( achAnsi ) )
|
||
{
|
||
ASSERT( FALSE );
|
||
*pwszUnicode = L'\0';
|
||
return 0;
|
||
}
|
||
|
||
achAnsi[cch] = '\0';
|
||
|
||
RtlCopyMemory( pwszUnicode, achAnsi, cch + 1 );
|
||
|
||
return (USHORT) cch;
|
||
} // ConvertUnicodeToAnsiInPlace()
|
||
|
||
|
||
|
||
BOOL
|
||
TS_DIRECTORY_HEADER::ReadFromNtDirectoryFile(
|
||
IN LPCWSTR pwszDirectoryName,
|
||
IN OUT DWORD * pcbMemUsed
|
||
)
|
||
/*++
|
||
Opens and reads the directory file for given directory to obtain
|
||
information about files and directories in the dir.
|
||
|
||
Returns:
|
||
TRUE on success and FALSE on failure.
|
||
Use GetLastError() for further error information.
|
||
|
||
--*/
|
||
{
|
||
BOOL fReturn = TRUE; // default assumed.
|
||
UNICODE_STRING PathName;
|
||
RTL_RELATIVE_NAME_U RelativeName;
|
||
OBJECT_ATTRIBUTES Obja;
|
||
HANDLE hFindFile = INVALID_HANDLE_VALUE;
|
||
NTSTATUS Status;
|
||
IO_STATUS_BLOCK IoStatusBlock;
|
||
BOOL fFirstTime;
|
||
DWORD cbExtraMem = 0;
|
||
|
||
PFILE_BOTH_DIR_INFORMATION pFileDirInfo;
|
||
PFILE_BOTH_DIR_INFORMATION pFileDirInfoPrior;
|
||
|
||
//
|
||
// Initialize the variables properly
|
||
//
|
||
|
||
memset( (PVOID ) &PathName, 0, sizeof(PathName));
|
||
memset( (PVOID ) &RelativeName, 0, sizeof(RelativeName));
|
||
|
||
//
|
||
// Convert the DOS name of directory to NT name for NT API to open it.
|
||
//
|
||
|
||
fReturn = RtlDosPathNameToRelativeNtPathName_U(
|
||
pwszDirectoryName,
|
||
&PathName,
|
||
NULL,
|
||
&RelativeName );
|
||
|
||
//
|
||
// If translation fails or
|
||
// If this directory name is in the form <dirname>\<filespec>,
|
||
// the caller has messed up.
|
||
//
|
||
|
||
if ( !fReturn || RelativeName.RelativeName.Length != 0) {
|
||
|
||
if (fReturn) {
|
||
RtlReleaseRelativeName(&RelativeName);
|
||
}
|
||
|
||
SetLastError(ERROR_PATH_NOT_FOUND);
|
||
|
||
if ( PathName.Buffer != NULL) { // free up the space.
|
||
|
||
RtlFreeHeap( RtlProcessHeap(), 0, PathName.Buffer);
|
||
}
|
||
|
||
return( fReturn);
|
||
}
|
||
|
||
//
|
||
// Remember that we need to free the buffer containing the NT name.
|
||
// i.e. PathName.Buffer
|
||
//
|
||
|
||
ASSERT( RelativeName.ContainingDirectory == NULL );
|
||
ASSERT( RelativeName.RelativeName.Length == 0);
|
||
|
||
InitializeObjectAttributes( &Obja,
|
||
&PathName,
|
||
OBJ_CASE_INSENSITIVE,
|
||
RelativeName.ContainingDirectory,
|
||
NULL );
|
||
|
||
//
|
||
// Open the directory for list access
|
||
//
|
||
|
||
Status = NtOpenFile( &hFindFile,
|
||
FILE_LIST_DIRECTORY | SYNCHRONIZE,
|
||
&Obja,
|
||
&IoStatusBlock,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT |
|
||
FILE_OPEN_FOR_BACKUP_INTENT
|
||
);
|
||
|
||
RtlReleaseRelativeName(&RelativeName);
|
||
|
||
//
|
||
// The Buffer is not required any more. Free it before checking status.
|
||
//
|
||
|
||
RtlFreeHeap( RtlProcessHeap(), 0, PathName.Buffer );
|
||
PathName.Buffer = NULL;
|
||
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
|
||
//
|
||
// The full path does not refer to a directory. This could be a
|
||
// device, but (unlike FindFirstFile()...) we don't care. If it's
|
||
// not a directory, we don't list it.
|
||
//
|
||
|
||
IF_DEBUG( DIR_LIST) {
|
||
DBGPRINTF( ( DBG_CONTEXT, "Failed to open Dir %ws. Handle = %x\n",
|
||
pwszDirectoryName, hFindFile));
|
||
}
|
||
|
||
SetLastError( ERROR_PATH_NOT_FOUND);
|
||
return ( FALSE);
|
||
}
|
||
|
||
InitializeListHead( &m_listDirectoryBuffers);
|
||
|
||
//
|
||
// Loop through getting subsequent entries in the directory.
|
||
//
|
||
for( fFirstTime = TRUE; ; fFirstTime = FALSE)
|
||
{
|
||
PVOID pvBuffer;
|
||
|
||
//
|
||
// Get the next chunk of directory information.
|
||
// Obtained in a buffer with LIST_ENTRY as the first member of buffer
|
||
//
|
||
|
||
#define DIR_ALLOC_SIZE (DIRECTORY_BUFFER_SIZE + sizeof (LIST_ENTRY))
|
||
|
||
pvBuffer = ALLOC( DIR_ALLOC_SIZE );
|
||
cbExtraMem += DIR_ALLOC_SIZE;
|
||
|
||
if ( pvBuffer == NULL ) {
|
||
|
||
//
|
||
// Allocation failure.
|
||
//
|
||
SetLastError( ERROR_NOT_ENOUGH_MEMORY);
|
||
fReturn = FALSE;
|
||
break; // Get out of the loop with failure.
|
||
}
|
||
|
||
pFileDirInfo = ( PFILE_BOTH_DIR_INFORMATION )
|
||
((( PCHAR ) pvBuffer) + sizeof( LIST_ENTRY ) );
|
||
|
||
Status = NtQueryDirectoryFile( hFindFile, // fileHandle
|
||
NULL, // Event
|
||
NULL, // Apc Routine
|
||
NULL, // ApcContext
|
||
&IoStatusBlock, // PIoStatusBlock
|
||
pFileDirInfo, // PFileInfo
|
||
DIRECTORY_BUFFER_SIZE, // Len
|
||
FileBothDirectoryInformation, //Class
|
||
FALSE, // fSingleEntry ?
|
||
NULL, //FileName
|
||
fFirstTime ); // RestartScan ?
|
||
|
||
//
|
||
// If the NT API returns STATUS_NO_MORE_FILES, then it did not use
|
||
// our buffer at all. We can just free it.
|
||
// Now's the time that we leave this loop, and stop reading the
|
||
// directory file.
|
||
//
|
||
|
||
if ( Status == STATUS_NO_MORE_FILES ) {
|
||
|
||
FREE( pvBuffer );
|
||
|
||
//
|
||
// Decrement the memory size so we don't get charged for it
|
||
//
|
||
|
||
cbExtraMem -= DIR_ALLOC_SIZE;
|
||
|
||
fReturn = TRUE;
|
||
break;
|
||
}
|
||
|
||
if ( NT_SUCCESS( Status ) || ( Status == STATUS_BUFFER_OVERFLOW ) )
|
||
{
|
||
|
||
ULONG Offset;
|
||
|
||
//
|
||
// The buffer contains directory entries.
|
||
// Place it on the list of such buffers for this directory.
|
||
//
|
||
|
||
InsertBufferInTail( (PLIST_ENTRY ) pvBuffer);
|
||
|
||
pFileDirInfoPrior = NULL;
|
||
|
||
//
|
||
// Scan thru the entries in the buffer,
|
||
// truncate the last entry ( if partial) and
|
||
// convert the Unicode strings, inplace to ansi strings.
|
||
//
|
||
|
||
do
|
||
{
|
||
pFileDirInfoPrior = pFileDirInfo;
|
||
|
||
Offset = pFileDirInfo->NextEntryOffset;
|
||
|
||
if ( ( Offset == 0 ) && ( Status == STATUS_BUFFER_OVERFLOW ) )
|
||
{
|
||
//
|
||
// If Status==STATUS_BUFFER_OVERFLOW, the last entry in
|
||
// buffer may be a partial entry, broken on boundary of
|
||
// buffer. The NT API will give us this entry again next
|
||
// time around, so for now we patch the buffer up to
|
||
// appear as if it does not contain the partial entry.
|
||
//
|
||
|
||
if ( pFileDirInfoPrior != NULL )
|
||
{
|
||
pFileDirInfoPrior->NextEntryOffset = 0;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Some fatal problem. Should get out this loop.
|
||
//
|
||
BREAKPOINT();
|
||
fReturn = FALSE;
|
||
goto Failure;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
IncrementDirEntries();
|
||
|
||
if ( pFileDirInfo->FileNameLength != 0) {
|
||
pFileDirInfo->FileNameLength =
|
||
ConvertUnicodeToAnsiInPlace(
|
||
(LPWSTR ) pFileDirInfo->FileName,
|
||
(USHORT ) pFileDirInfo->FileNameLength);
|
||
}
|
||
|
||
if ( pFileDirInfo->ShortNameLength != 0) {
|
||
pFileDirInfo->ShortNameLength =
|
||
(CCHAR ) ConvertUnicodeToAnsiInPlace(
|
||
(LPWSTR ) pFileDirInfo->ShortName,
|
||
pFileDirInfo->ShortNameLength);
|
||
}
|
||
|
||
|
||
// Get the next entry in buffer
|
||
pFileDirInfo =
|
||
( PFILE_BOTH_DIR_INFORMATION )
|
||
((( PCHAR )pFileDirInfo ) + Offset );
|
||
}
|
||
}
|
||
while ( Offset != 0);
|
||
|
||
Status = STATUS_SUCCESS;
|
||
}
|
||
|
||
if ( !NT_SUCCESS(Status) )
|
||
{
|
||
fReturn = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
Failure:
|
||
|
||
ASSERT( PathName.Buffer == NULL);
|
||
if ( hFindFile != INVALID_HANDLE_VALUE) {
|
||
NtClose( hFindFile );
|
||
hFindFile = INVALID_HANDLE_VALUE;
|
||
}
|
||
|
||
*pcbMemUsed += cbExtraMem;
|
||
|
||
return ( fReturn);
|
||
} // TS_DIRECTORY_HEADER::ReadFromNtDirectoryFile()
|
||
|
||
|
||
|
||
|
||
VOID
|
||
TS_DIRECTORY_HEADER::CleanupThis( VOID)
|
||
{
|
||
PLIST_ENTRY pEntry;
|
||
PLIST_ENTRY pNextEntry;
|
||
|
||
for ( pEntry = QueryDirBuffersListEntry()->Flink;
|
||
pEntry != QueryDirBuffersListEntry();
|
||
pEntry = pNextEntry )
|
||
{
|
||
pNextEntry = pEntry->Flink;
|
||
|
||
//
|
||
// The buffers are allocated such that first member of buffer is
|
||
// LIST_ENTRY object. Free it entirely.
|
||
//
|
||
FREE( pEntry );
|
||
}
|
||
|
||
InitializeListHead( QueryDirBuffersListEntry());
|
||
|
||
if ( m_ppFileInfo != NULL) {
|
||
|
||
FREE( m_ppFileInfo);
|
||
m_ppFileInfo = NULL;
|
||
}
|
||
|
||
m_hListingUser = INVALID_HANDLE_VALUE;
|
||
m_nEntries = 0;
|
||
|
||
return;
|
||
} // TS_DIRECTORY_HEADER::CleanupThis()
|
||
|
||
|
||
|
||
|
||
|
||
BOOL
|
||
TS_DIRECTORY_HEADER::BuildFileInfoPointers(
|
||
IN OUT DWORD * pcbMemUsed
|
||
)
|
||
/*++
|
||
|
||
This constructs the indirection pointers from the buffers containing the
|
||
file information.
|
||
This array of indirection enables faster access to the file information
|
||
structures stored.
|
||
|
||
Should be always called after ReadFromNtDirectoryFile() to construct the
|
||
appropriate pointers.
|
||
|
||
Returns:
|
||
TRUE on success and FALSE if there are any failures.
|
||
--*/
|
||
{
|
||
BOOL fReturn = FALSE;
|
||
DWORD cbAlloc;
|
||
|
||
ASSERT( QueryNumEntries() != 0); // Any directory will atleast have "."
|
||
|
||
//
|
||
// Alloc space for holding the pointers for numEntries pointers.
|
||
//
|
||
|
||
cbAlloc = QueryNumEntries() * sizeof( PFILE_BOTH_DIR_INFORMATION );
|
||
|
||
m_ppFileInfo = (PFILE_BOTH_DIR_INFORMATION *) ALLOC( cbAlloc );
|
||
|
||
if ( m_ppFileInfo != NULL ) {
|
||
|
||
int index;
|
||
PLIST_ENTRY pEntry;
|
||
ULONG Offset;
|
||
PFILE_BOTH_DIR_INFORMATION pFileDirInfo;
|
||
|
||
//
|
||
// Get the link to first buffer and start enumeration.
|
||
//
|
||
pEntry = QueryDirBuffersListEntry()->Flink;
|
||
pFileDirInfo = (PFILE_BOTH_DIR_INFORMATION )( pEntry + 1 );
|
||
|
||
for ( index = 0;
|
||
index < QueryNumEntries();
|
||
index++ ) {
|
||
|
||
ASSERT( pEntry != QueryDirBuffersListEntry());
|
||
|
||
m_ppFileInfo[index] = pFileDirInfo; // store the pointer.
|
||
|
||
Offset = pFileDirInfo->NextEntryOffset;
|
||
|
||
if ( Offset != 0 ) {
|
||
|
||
pFileDirInfo = (PFILE_BOTH_DIR_INFORMATION )
|
||
((( PCHAR )pFileDirInfo ) + Offset );
|
||
} else {
|
||
|
||
//
|
||
// we are moving to the next buffer.
|
||
//
|
||
pEntry = pEntry->Flink;
|
||
if ( pEntry == QueryDirBuffersListEntry()) {
|
||
|
||
ASSERT( index == QueryNumEntries() - 1);
|
||
break;
|
||
}
|
||
pFileDirInfo = ( PFILE_BOTH_DIR_INFORMATION )( pEntry + 1 );
|
||
}
|
||
|
||
|
||
} // for
|
||
ASSERT( Offset == 0 );
|
||
fReturn = SortInPlaceFileInfoPointers( m_ppFileInfo,
|
||
QueryNumEntries(),
|
||
AlphaCompareFileBothDirInfo);
|
||
|
||
} // valid alloc of the pointers.
|
||
|
||
*pcbMemUsed += cbAlloc;
|
||
|
||
return ( fReturn);
|
||
} // TS_DIRECTORY_HEADER::BuildFileInfoPointers()
|
||
|
||
|
||
|
||
|
||
# if DBG
|
||
|
||
VOID
|
||
TS_DIRECTORY_HEADER::Print( VOID) const
|
||
{
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
"Printing TS_DIRECTORY_HEADER ( %08x).\n", this));
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
"ListingUser Handle = %08x\t Num Entries = %08x\n",
|
||
m_hListingUser, m_nEntries));
|
||
DBGPRINTF( ( DBG_CONTEXT,
|
||
"Pointer to array of indirection pointers %08x\n",
|
||
m_ppFileInfo));
|
||
//
|
||
// The buffers containing the data of the file information not printed
|
||
//
|
||
|
||
return;
|
||
} // TS_DIRECTORY_HEADER::Print()
|
||
|
||
|
||
# endif // DBG
|
||
|
||
/************************ End of File ***********************/
|
||
|