able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/svcs/infocomm/cache/virtroot.cxx

660 lines
18 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name :
virtroot.cxx
Abstract:
This module defines functions for managing virtual roots.
Author:
??? ( ???) ??-??-1994/5
Environment:
User Mode -- Win32
Project:
TSunami DLL for Internet Services
Functions Exported:
Revision History:
MuraliK Added File System type to information stored about
each virtual root.
MuraliK Modified TsLookupVirtualRoot() to support variable
length buffer and hence check for invalid writes
MuraliK 22-Jan-1996 Cache & return UNC virtual root impersonation
token.
--*/
/************************************************************
* Include Headers
************************************************************/
#include "TsunamiP.Hxx"
#pragma hdrstop
#include <mbstring.h>
#include <rpc.h>
#include <rpcndr.h>
#include "dbgutil.h"
#include <string.h>
#include <refb.hxx>
#include <imd.h>
#include <mb.hxx>
#include <iiscnfg.h>
IIS_VROOT_TABLE::IIS_VROOT_TABLE(
VOID
)
:
m_nVroots (0 )
{
InitializeCriticalSection( &m_csLock );
InitializeListHead( &m_vrootListHead );
} // IIS_VROOT_TABLE::IIS_VROOT_TABLE
IIS_VROOT_TABLE::~IIS_VROOT_TABLE(
VOID
)
{
RemoveVirtualRoots( );
DeleteCriticalSection( &m_csLock );
DBG_ASSERT( m_nVroots == 0 );
DBG_ASSERT( IsListEmpty( &m_vrootListHead ) );
} // IIS_VROOT_TABLE::~IIS_VROOT_TABLE
BOOL
IIS_VROOT_TABLE::AddVirtualRoot(
PCHAR pszRoot,
PCHAR pszDirectory,
DWORD dwAccessMask,
PCHAR pszAccountName,
HANDLE hImpersonationToken,
DWORD dwFileSystem
)
/*++
Description:
This function adds a symbolic link root and directory mapping
part to the virtual root list
We always strip trailing slashes from the root and directory name.
If the root is "\" or "/", then the effective root will be zero
length and will always be placed last in the list. Thus if a lookup
can't find a match, it will always match the last entry.
Arguments:
pszRoot - Virtual symbolic link root
pszDirectory - Physical directory
dwAccessMask - Type of access allowed on this virtual root
pszAccountName - User name to impersonate if UNC (only gets stored
for RPC apis)
hImpersonationToken - Impersonation token to use for UNC
directory paths
dwFileSystem - DWORD containing the file system type
( symbolic constant)
Returns:
TRUE on success and FALSE if any failure.
--*/
{
PVIRTUAL_ROOT_MAPPING pVrm, pVrmOld;
PDIRECTORY_CACHING_INFO pDci;
PLIST_ENTRY pEntry;
BOOL fRet = FALSE;
BOOL fUNC;
DWORD cchRoot;
if ( !pszRoot || !*pszRoot || !pszDirectory || !*pszDirectory )
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
//
// Disallow allow UNC roots if we don't have an impersonation token and
// this isn't a placeholder
//
fUNC = (BOOL)((pszDirectory[0] == '\\') && (pszDirectory[1] == '\\'));
//
// Strip the trailing '/' from the virtual root
//
cchRoot = strlen( pszRoot );
if ( IS_CHAR_TERM_A( pszRoot, cchRoot - 1))
{
pszRoot[--cchRoot] = '\0';
}
//
// Look in the current list and see if the root is already there.
// If the directory is the same, we just return success. If the
// directory is different, we remove the old item and add the new one.
//
LockTable();
for ( pEntry = m_vrootListHead.Flink;
pEntry != &m_vrootListHead;
pEntry = pEntry->Flink )
{
pVrm = CONTAINING_RECORD( pEntry, VIRTUAL_ROOT_MAPPING, TableListEntry );
//
// If we have a match up to the length of the previously added root
// and the new item is a true match (as opposed to a matching prefix)
// and the matching item isn't the default root (which matches against
// everything cause it's zero length)
//
if ( (cchRoot == pVrm->cchRootA) &&
!_mbsnicmp( (PUCHAR)pszRoot, (PUCHAR)pVrm->pszRootA, _mbslen((PUCHAR)pVrm->pszRootA) ) &&
IS_CHAR_TERM_A( pszRoot, pVrm->cchRootA ) &&
((pVrm->cchRootA != 0) || (cchRoot == 0)) )
{
if ( !lstrcmpi( pszDirectory, pVrm->pszDirectoryA ) &&
IS_CHAR_TERM_A( pszDirectory, pVrm->cchDirectoryA ))
{
//
// This root is already in the list
//
UnlockTable();
return TRUE;
} else{
//
// A root is having its directory entry changed
//
//
// If last item on this dir, need to remove from list(s?),
// free dir handle, free memory
//
UnlockTable();
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
}
}
}
UnlockTable();
pVrm = ( PVIRTUAL_ROOT_MAPPING )ALLOC( sizeof( VIRTUAL_ROOT_MAPPING ) +
sizeof( DIRECTORY_CACHING_INFO ));
pDci = ( PDIRECTORY_CACHING_INFO)( pVrm+1 );
if ( pVrm == NULL )
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return FALSE;
}
//
// Initialize the new root item
//
pVrm->Signature = VIRT_ROOT_SIGNATURE;
pVrm->cchRootA = strlen( pszRoot );
pVrm->cchDirectoryA = strlen( pszDirectory );
pVrm->dwFileSystem = dwFileSystem;
pVrm->dwAccessMask = dwAccessMask;
InitializeListHead(&pVrm->GlobalListEntry);
pDci->hDirectoryFile = NULL;
pDci->fOnSystemNotifyList = FALSE;
pVrm->fCachingAllowed = FALSE;
pVrm->fUNC = fUNC;
pVrm->fDeleted = FALSE;
pVrm->hImpersonationToken = hImpersonationToken;
//
// Set the initial reference count to 2. Once when TsRemoveVirtualRoots
// is called and once when the Apc completes
//
pVrm->cRef = 2;
strcpy( pVrm->pszRootA, pszRoot );
strcpy( pVrm->pszDirectoryA, pszDirectory );
strcpy( pVrm->pszAccountName, pszAccountName ? pszAccountName : "" );
//
// Strip trailing slashes from the root and directory
//
if ( (pVrm->cchRootA != 0) &&
IS_CHAR_TERM_A( pVrm->pszRootA, pVrm->cchRootA - 1 ))
{
pVrm->pszRootA[--pVrm->cchRootA] = '\0';
}
if ( IS_CHAR_TERM_A( pVrm->pszDirectoryA, pVrm->cchDirectoryA - 1))
{
//
// Note we assume virtual directories always begin with a '/...' to
// provide the necessary path separator between the root directory
// path and the remaining virtual directory
//
pVrm->pszDirectoryA[--pVrm->cchDirectoryA] = '\0';
}
//
// Add the item to the list
//
LockTable();
//
// If the root is zero length, then it will match all occurrences so put
// it last. Note this is useful for default root entries (such as "/").
//
if ( pVrm->cchRootA == 0 ) {
//
// Roots that specify an address go in front of roots that do not
// thus giving precedence to matching roots w/ addresses
//
InsertTailList( &m_vrootListHead, &pVrm->TableListEntry );
} else {
//
// Insert the virtual root in descending length of their
// virtual root name, i.e.,
//
// /abc/123, /abc/12, /abc, /a
//
// This ensures matches occur on the longest possible virtual root
//
for ( pEntry = m_vrootListHead.Flink;
pEntry != &m_vrootListHead;
pEntry = pEntry->Flink )
{
pVrmOld = CONTAINING_RECORD( pEntry,
VIRTUAL_ROOT_MAPPING,
TableListEntry );
if ( pVrmOld->cchRootA < pVrm->cchRootA )
{
pVrm->TableListEntry.Flink = pEntry;
pVrm->TableListEntry.Blink = pEntry->Blink;
pEntry->Blink->Flink = &pVrm->TableListEntry;
pEntry->Blink = &pVrm->TableListEntry;
goto Added;
}
}
//
// There aren't any named roots so put this root
// at the beginning
//
InsertHeadList( &m_vrootListHead, &pVrm->TableListEntry );
}
Added:
if ( !(fRet = DcmAddRoot( pVrm ))) {
RemoveEntryList( &pVrm->TableListEntry );
UnlockTable();
goto Failure;
}
m_nVroots++;
UnlockTable();
IF_DEBUG( VIRTUAL_ROOTS )
DBGPRINTF(( DBG_CONTEXT,
" - %s => %s\n",
pVrm->pszRootA,
pVrm->pszDirectoryA ));
return TRUE;
Failure:
DBGPRINTF(( DBG_CONTEXT,
" Error %d adding - %s => %s\n",
GetLastError(),
pVrm->pszRootA,
pVrm->pszDirectoryA ));
FREE( pVrm );
return fRet;
} // IIS_VROOT_TABLE::AddVirtualRoot
BOOL
IIS_VROOT_TABLE::LookupVirtualRoot(
IN const CHAR * pszVirtPath,
OUT CHAR * pszDirectory,
IN OUT LPDWORD lpcbSize,
OUT LPDWORD lpdwAccessMask, // Optional
OUT LPDWORD pcchDirRoot, // Optional
OUT LPDWORD pcchVRoot, // Optional
OUT HANDLE * phImpersonationToken, // Optional
OUT LPDWORD lpdwFileSystem // Optional
)
/*++
Description:
This function looks in the map list for the specified root
and returns the corresponding directory
Arguments:
pszVirtPath - Virtual symbolic link path
pszDirectory - receives Physical directory.
This is of the size specified by lpcbSize
lpcbSize - pointer to DWORD containing the size of buffer pszDirectory
On retur contains the number of bytes written
lpdwAccessMask - The access mask for this root
pcchDirRoot - Number of characters of the directory this virtual
root maps to (i.e., /foo/ ==> c:\root, lookup "/foo/bar/abc.htm"
this value returns the length of "c:\root")
pcchVRoot - Number of characters that made up the found virtual root
(i.e., returns the lenght of "/foo/")
phImpersonationToken - pointer to handle object that will contain
the handle to be used for impersonation for UNC/secure virtual roots
lpdwFileSystem - on successful return will contain the file system
type for the directory matched with root specified.
Returns:
TRUE on success and FALSE if any failure.
History:
MuraliK 28-Apr-1995 Improved robustness
MuraliK 18-Jan-1996 Support imperonstaion token
Note:
This function is growing in the number of parameters returned.
Maybe we should expose the VIRTUAL_ROOT_MAPPING structure
and return a pointer to this object and allow the callers to
extract all required pieces of data.
--*/
{
DWORD dwError = NO_ERROR;
PVIRTUAL_ROOT_MAPPING pVrm;
PLIST_ENTRY pEntry;
DBG_ASSERT( pszDirectory != NULL);
DBG_ASSERT( lpcbSize != NULL);
LockTable();
for ( pEntry = m_vrootListHead.Flink;
pEntry != &m_vrootListHead;
pEntry = pEntry->Flink )
{
pVrm = CONTAINING_RECORD( pEntry, VIRTUAL_ROOT_MAPPING, TableListEntry );
ASSERT( pVrm->Signature == VIRT_ROOT_SIGNATURE );
//
// If the virtual paths match and (the addresses match
// or this is a global address for this service)
//
if ( !_mbsnicmp( (PUCHAR)pszVirtPath,
(PUCHAR)pVrm->pszRootA,
_mbslen( (PUCHAR)pVrm->pszRootA ) ) &&
IS_CHAR_TERM_A( pszVirtPath, pVrm->cchRootA ) )
{
//
// we found a match. return all requested parameters.
//
DWORD cbReqd = ( pVrm->cchDirectoryA +
strlen(pszVirtPath + pVrm->cchRootA));
if ( cbReqd <= *lpcbSize) {
PCHAR pathStart = pszDirectory + pVrm->cchDirectoryA;
//
// Copy the physical directory base then append the rest of
// the non-matching virtual path
//
CopyMemory(
pszDirectory,
pVrm->pszDirectoryA,
pVrm->cchDirectoryA
);
strcpy( pathStart,
pszVirtPath + pVrm->cchRootA );
if ( lpdwFileSystem != NULL) {
*lpdwFileSystem = pVrm->dwFileSystem;
}
if ( pcchDirRoot ) {
*pcchDirRoot = pVrm->cchDirectoryA;
}
if ( pcchVRoot ) {
*pcchVRoot = pVrm->cchRootA;
}
if ( lpdwAccessMask != NULL) {
*lpdwAccessMask = pVrm->dwAccessMask;
}
if ( phImpersonationToken != NULL) {
// Should we increment refcount of the impersonation token?
*phImpersonationToken = pVrm->hImpersonationToken;
}
UnlockTable();
FlipSlashes( pathStart );
*lpcbSize = cbReqd;
return(TRUE);
} else {
dwError = ERROR_INSUFFICIENT_BUFFER;
}
*lpcbSize = cbReqd;
break;
}
} // for
UnlockTable();
if ( lpdwAccessMask ) {
*lpdwAccessMask = 0;
}
if ( lpdwFileSystem != NULL) {
*lpdwFileSystem = FS_ERROR;
}
if ( phImpersonationToken != NULL) {
*phImpersonationToken = NULL;
}
if ( dwError == NO_ERROR) {
dwError = ERROR_PATH_NOT_FOUND;
}
SetLastError( dwError );
return FALSE;
} // IIS_VROOT_TABLE::LookupVirtualRoot
BOOL
IIS_VROOT_TABLE::RemoveVirtualRoots(
VOID
)
/*++
Description:
Removes all of the virtual roots for the instance
Arguments:
None.
Returns:
TRUE on success and FALSE if any failure.
--*/
{
PVIRTUAL_ROOT_MAPPING pVrm;
PLIST_ENTRY pEntry;
PLIST_ENTRY pEntryFile;
PLIST_ENTRY pNextEntry;
PCACHE_OBJECT pCache;
PDIRECTORY_CACHING_INFO pDci;
BOOL bSuccess;
//
// If both locks are going to be taken, taken the cache table lock first
// to avoid deadlock with the change notification thread.
//
// Note the table lock (m_csLock) needs to be taken before the
// csVirtualRoots lock. We must take csVirtualRoots lock to synchronize
// with the ChangeWaitThread().
//
EnterCriticalSection( &CacheTable.CriticalSection );
LockTable();
EnterCriticalSection( &csVirtualRoots );
for ( pEntry = m_vrootListHead.Flink;
pEntry != &m_vrootListHead;
pEntry = pEntry->Flink )
{
pVrm = CONTAINING_RECORD( pEntry, VIRTUAL_ROOT_MAPPING, TableListEntry );
ASSERT( pVrm->Signature == VIRT_ROOT_SIGNATURE );
pDci = (PDIRECTORY_CACHING_INFO) (pVrm + 1);
if ( pVrm->fCachingAllowed )
{
//
// Indicate this root is deleted before we close the dir
// handle. When the APC notification of the aborted IO
// completes, it will dereference all deleted items
//
pVrm->fDeleted = TRUE;
CLOSE_DIRECTORY_HANDLE( pDci );
//
// Close any open files on this virtual root
//
if ( !TsDecacheVroot( pDci ) ) {
DBGPRINTF(( DBG_CONTEXT,
"Warning - TsDecacheVroot failed!\n" ));
}
}
else
{
CLOSE_DIRECTORY_HANDLE( pDci );
}
pEntry = pEntry->Blink;
RemoveEntryList( pEntry->Flink );
m_nVroots--;
IF_DEBUG( DIRECTORY_CHANGE )
DBGPRINTF(( DBG_CONTEXT,
"Removing root %s\n",
pVrm->pszDirectoryA ));
//
// Remove from global list too
//
DcmRemoveRoot( pVrm );
DereferenceRootMapping( pVrm );
}
LeaveCriticalSection( &csVirtualRoots );
UnlockTable();
LeaveCriticalSection( &CacheTable.CriticalSection );
return TRUE;
} // TsRemoveVirtualRoots
VOID
DereferenceRootMapping(
IN OUT PVIRTUAL_ROOT_MAPPING pVrm
)
{
if ( !InterlockedDecrement( &pVrm->cRef )) {
// DBGPRINTF((DBG_CONTEXT,"*** Deleting VRM memory ***\n"));
//
// We need to close the impersonation token, if one exists.
//
if ( pVrm->hImpersonationToken != NULL) {
DBG_REQUIRE( CloseHandle( pVrm->hImpersonationToken ));
pVrm->hImpersonationToken = NULL;
}
pVrm->Signature = 0;
FREE( pVrm );
}
return;
} // DereferenceRootMapping

Reference in a new issue Copy permalink