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

771 lines
16 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995-1996 Microsoft Corporation
Module Name :
setable.cxx
Abstract:
This module declares the SE_TABLE object which consists
of all the extensions for W3 service
Author:
Murali R. Krishnan ( MuraliK ) 18-July-1996
Environment:
User Mode - Win32
Project:
W3 Services DLL
--*/
/************************************************************
* Include Headers
************************************************************/
# include <isapip.hxx>
# include "isapidll.hxx"
# include "setable.hxx"
# include <issched.hxx>
/************************************************************
* Global Data
************************************************************/
PSE_TABLE g_psextensions; // all extensions
static BOOL g_fExtInitialized = FALSE;
/**************************************************
* Member functions of SESD_LIST
**************************************************/
SESD_LIST::SESD_LIST(VOID)
: m_idWorkItem( 0)
{
INITIALIZE_CRITICAL_SECTION( &m_csLock);
InitializeListHead( &m_Head);
} // SESD_LIST::SESD_LIST()
SESD_LIST::~SESD_LIST(VOID)
{
// Should be all done
DBG_ASSERT( 0 == m_idWorkItem);
DBG_ASSERT( IsListEmpty( &m_Head));
DeleteCriticalSection( &m_csLock);
} // SESD_LIST::~SESD_LIST()
VOID
SESD_LIST::ScheduleExtensionForDeletion(
IN PHSE psExt
)
{
Lock();
// add to the list
InsertHeadList( &m_Head, &psExt->m_ListEntry);
if ( 0 == m_idWorkItem) {
// schedule the work item if not scheduled one already
m_idWorkItem = ScheduleWorkItem( SchedulerCallback, this, 0);
DBG_ASSERT( 0 != m_idWorkItem);
}
Unlock();
return;
} // SESD_LIST::ScheduleExtensionForDeletion()
VOID
SESD_LIST::WaitTillFinished(VOID)
{
Lock();
// wait until nothing is scheduled
while ( 0 != m_idWorkItem) {
// let it drain itself while in the unlocked state
Unlock();
Sleep( 200 );
Lock();
}
Unlock();
return;
} // SESD_LIST::WaitTillFinished()
VOID
WINAPI
SESD_LIST::SchedulerCallback(
void *pvContext
)
{
DBG_ASSERT( NULL != pvContext);
((SESD_LIST *)pvContext)->DeleteScheduledExtensions();
return;
} // SESD_LIST::SchedulerCallback()
VOID
SESD_LIST::DeleteScheduledExtensions(VOID)
{
PHSE psExt;
Lock();
// If it is scheduled there better be a reason why
DBG_ASSERT( 0 != m_idWorkItem);
while ( !IsListEmpty( &m_Head)) {
// extract extension from the list and delete it
psExt = CONTAINING_RECORD( m_Head.Flink,
HSE_BASE,
m_ListEntry );
RemoveEntryList( &psExt->m_ListEntry );
InitializeListHead( &psExt->m_ListEntry);
delete psExt;
} // while
// reset to 0 to indicate that we are done
m_idWorkItem = 0;
Unlock();
return;
} // SESD_LIST::DeleteScheduledExtensions()
/**************************************************
* Member functions of SE_TABLE
**************************************************/
SE_TABLE::SE_TABLE(VOID)
: m_cRefWams ( 0)
{
IF_DEBUG( INIT_CLEAN) {
DBGPRINTF(( DBG_CONTEXT, "Constructing SE_TABLE(%08x)\n", this));
}
INITIALIZE_CRITICAL_SECTION( &m_csLock);
InitializeListHead( &m_ExtensionHead);
} // SE_TABLE::SE_TABLE()
SE_TABLE::~SE_TABLE(VOID)
{
IF_DEBUG( INIT_CLEAN) {
DBGPRINTF(( DBG_CONTEXT, "Deleteing SE_TABLE(%08x) cWamRef=%d\n",
this, m_cRefWams));
}
// unload all the extensions if not already done
DBG_REQUIRE( UnloadExtensions());
// No WAM should be holding ref to the SE_TABLE
DBG_ASSERT( 0 == m_cRefWams);
DeleteCriticalSection( &m_csLock);
DBG_ASSERT( IsListEmpty( &m_ExtensionHead));
} // SE_TABLE::~SE_TABLE()
VOID
SE_TABLE::Print(VOID)
{
PLIST_ENTRY pEntry;
int i = 0;
// NYI: I need to write code to print out data here.
DBGPRINTF(( DBG_CONTEXT,
" SE_TABLE(%08x) ListHead=%08x [%08x:%08x] cRefWams=%d\n",
this, &m_ExtensionHead,
m_ExtensionHead.Flink, m_ExtensionHead.Blink,
m_cRefWams
));
Lock();
for ( pEntry = m_ExtensionHead.Flink;
(pEntry != &m_ExtensionHead);
pEntry = pEntry->Flink, i++ )
{
HSE_BASE *
pExtension = CONTAINING_RECORD( pEntry, HSE_BASE, m_ListEntry );
DBGPRINTF(( DBG_CONTEXT,
" Dll(%d): HSE_BASE = %08x [%08x:%08x]; Module=%s\n",
i, pExtension,
pExtension->m_ListEntry.Flink,
pExtension->m_ListEntry.Blink,
pExtension->QueryModuleName()));
} // for all entries in table
Unlock();
return;
} // SE_TABLE::Print()
BOOL
SE_TABLE::GetExtension(
IN const CHAR * pchModuleName,
IN HANDLE hImpersonation,
IN BOOL fCacheImpersonation,
IN BOOL fCache,
OUT PHSE * ppsExt
)
/*++
Routine Description:
Retrieves an extension's DLL entry point
The appropriate user should be impersonated before calling this function
Arguments:
pchModuleName - Extension DLL module name
hImpersonation - Impersonation token of user making this call
fCacheImpersonation - if TRUE, the hImpersonation can be cached
fCache - TRUE if this item should be cached, FALSE otherwise
ppsExt - pointer to the Extensions handler object
Return Value:
TRUE if successful, FALSE on error
--*/
{
LIST_ENTRY * pEntry;
HSE_BASE * pExtension = NULL;
BOOL fRet = FALSE;
IF_DEBUG( BGI ) {
DBGPRINTF(( DBG_CONTEXT, "[GetEntryPoint] Looking for module %s\n",
pchModuleName ));
}
//
// NYI: Optimize the locked section here - reduce time spent inside
// the locked block.
// Check cache to see if DLL is already loaded
//
DWORD cchModuleName = strlen( pchModuleName);
Lock();
for ( pEntry = m_ExtensionHead.Flink;
pEntry != &m_ExtensionHead;
pEntry = pEntry->Flink )
{
pExtension = CONTAINING_RECORD( pEntry, HSE_BASE, m_ListEntry );
if ( pExtension->IsMatch( pchModuleName, cchModuleName)) {
//
// Already Loaded, return the extension object after access check
//
fRet = TRUE;
break;
} // a match
} // for all entries in table
IF_DEBUG( BGI ) {
DBGPRINTF(( DBG_CONTEXT,
"[GetEntryPoint] Lookup module %s => fRet =%d\n",
pchModuleName, fRet ));
}
if ( !fRet) {
//
// The module is not loaded. Load the module now.
// The module name refers to an ISAPI application.
// Try ISAPI app loader now...
pExtension = HSE_APPDLL::LoadModule( pchModuleName,
hImpersonation,
fCache);
fRet = (pExtension != NULL);
if (fRet) {
if ( !fCache) {
// Temporarily the ref count will drop to 0, but the code below
// will bump this up to 1.
pExtension->Dereference();
} else {
// add this extension to the list of cached extensions
InsertIntoListWithLock( pExtension);
}
} else {
DBGPRINTF((DBG_CONTEXT,
"LoadModule failed with %x\n",GetLastError()));
}
}
if ( fRet ) {
if ( pExtension->AccessCheck( hImpersonation, fCacheImpersonation)) {
DBG_ASSERT( pExtension != NULL);
if ( ppsExt != NULL) {
// ref the object before giving ptr away
pExtension->Reference();
*ppsExt = pExtension;
}
} else {
fRet = FALSE;
}
}
Unlock();
return fRet;
} // SE_TABLE::GetExtension()
BOOL
SE_TABLE::RefreshAcl(
IN const CHAR * pchDLL
)
/*++
Routine Description:
This function reloads the ACL on an ISAPI Application .dll after that
.dll has already been loaded.
Arguments:
pchDLL - pointer to the ISAPI DLL for which ACL has to be refreshed.
Return Value:
TRUE on success, FALSE on failure
--*/
{
LIST_ENTRY * pEntry;
PHSE pExtension;
BOOL fRet = FALSE;
BOOL fFound = FALSE;
IF_DEBUG( BGI )
{
DBGPRINTF(( DBG_CONTEXT,
"[RefreshISAPIAcl] Rereading ACL for %s\n",
pchDLL ));
}
//
// Check cache to see if the DLL is loaded
//
DWORD cchDll = strlen( pchDLL);
Lock();
for ( pEntry = m_ExtensionHead.Flink;
pEntry != &m_ExtensionHead;
pEntry = pEntry->Flink )
{
pExtension = CONTAINING_RECORD( pEntry, HSE_BASE, m_ListEntry );
if ( pExtension->IsMatch( pchDLL, cchDll) )
{
//
// Force an access check on the next request with the new ACL
//
fRet = pExtension->LoadAcl();
fFound = TRUE;
break;
}
}
Unlock();
if ( !fFound) { SetLastError( ERROR_FILE_NOT_FOUND ); }
return (fRet);
} // SE_TABLE::RefreshAcl()
BOOL
SE_TABLE::RefreshAcl(
IN DWORD dwId
)
/*++
Routine Description:
This function reloads the ACL on an ISAPI Application .dll after that
.dll has already been loaded.
Arguments:
pchDLL - pointer to the ISAPI DLL for which ACL has to be refreshed.
Return Value:
TRUE on success, FALSE on failure
--*/
{
LIST_ENTRY * pEntry;
PHSE pExtension;
BOOL fRet = FALSE;
BOOL fFound = FALSE;
IF_DEBUG( BGI )
{
DBGPRINTF(( DBG_CONTEXT,
"[RefreshISAPIAcl] Rereading ACL for %d\n",
dwId ));
}
//
// Check cache to see if the DLL is loaded
//
Lock();
for ( pEntry = m_ExtensionHead.Flink;
pEntry != &m_ExtensionHead;
pEntry = pEntry->Flink )
{
pExtension = CONTAINING_RECORD( pEntry, HSE_BASE, m_ListEntry );
if ( pExtension->GetDirMonitorId() == dwId )
{
//
// Force an access check on the next request with the new ACL
//
fRet = pExtension->LoadAcl();
fFound = TRUE;
break;
}
}
Unlock();
if ( !fFound) { SetLastError( ERROR_FILE_NOT_FOUND ); }
return (fRet);
} // SE_TABLE::RefreshAcl()
BOOL
SE_TABLE::FlushAccessToken(
IN HANDLE hAccTok
)
/*++
Routine Description:
Reset last successfull user it same as hAccTok
Arguments:
hAccTok - access token to remove from cache
Return Value:
TRUE on success, FALSE on failure
--*/
{
LIST_ENTRY * pEntry;
HSE_APPDLL * pExtension;
BOOL fRet = FALSE;
BOOL fFound = FALSE;
IF_DEBUG( BGI )
{
DBGPRINTF(( DBG_CONTEXT,
"[FlushAccessToken] removing handle %x from cache\n",
hAccTok ));
}
//
// Check cache for access token
//
Lock();
for ( pEntry = m_ExtensionHead.Flink;
pEntry != &m_ExtensionHead;
pEntry = pEntry->Flink )
{
pExtension = CONTAINING_RECORD( pEntry, HSE_APPDLL, m_ListEntry );
if ( pExtension->QueryLastSuccessfulUser() == hAccTok )
{
//
// Force an access check on the next request for this token
//
pExtension->SetLastSuccessfulUser( NULL );
}
}
Unlock();
return TRUE;
} // SE_TABLE::RefreshAcl()
BOOL
SE_TABLE::UnloadExtensions(VOID)
{
PHSE psExt;
DBG_ASSERT( m_cRefWams == 0);
Lock();
while ( !IsListEmpty( &m_ExtensionHead )) {
psExt = CONTAINING_RECORD( m_ExtensionHead.Flink,
HSE_BASE,
m_ListEntry );
//
// Move from the current list to the UnloadList
//
RemoveEntryList( &psExt->m_ListEntry );
InitializeListHead( &psExt->m_ListEntry); // Cleanup
IF_DEBUG( INIT_CLEAN) {
DBGPRINTF(( DBG_CONTEXT,
"Deref of HSE_APPDLL(%08x) = %s. Ref=%d\n",
psExt, psExt->QueryModuleName(), psExt->RefCount()));
}
//
// Cause an Unload of the ISAPI DLL
// Ugly cast should be cleaned up post-beta2
//
DBG_REQUIRE( ((HSE_APPDLL * )psExt)->Unload() == NO_ERROR);
// Decrement the life reference count of the ISAPI DLL structure
if ( !psExt->Dereference()) {
delete psExt;
}
} // while
Unlock();
// Drain the list of non-cached extensions scheduled for deletion
m_sesdExtensions.WaitTillFinished();
return (TRUE);
} // SE_TABLE::UnloadExtensions()
VOID
SE_TABLE::PrintRequestCounts(VOID)
/*++
Description:
Prints a summary of all the ISAPI Dlls loaded and the # requests
pending in each of them primarily for debugging purposes.
Arguments:
None
Return:
None
--*/
{
PHSE psExt;
PLIST_ENTRY pEntry;
Lock();
if( m_ExtensionHead.Flink != &m_ExtensionHead ) {
DBGPRINTF( (DBG_CONTEXT, "SE_TABLE::Printing refs for all loaded ISAPI\n") );
for ( pEntry = m_ExtensionHead.Flink;
pEntry != &m_ExtensionHead;
pEntry = pEntry->Flink )
{
psExt = CONTAINING_RECORD( pEntry, HSE_BASE, m_ListEntry );
RemoveEntryList( &psExt->m_ListEntry );
DBGPRINTF( (DBG_CONTEXT,
" \'%s\') has RefCount = %d\n",
psExt->QueryModuleName(),
psExt->RefCount()
) );
} // for
DBGPRINTF( (DBG_CONTEXT, "-------------------------------\n") );
} // if
Unlock();
return;
} // SE_TABLE::PrintRequestCounts()
VOID
SE_TABLE::ReleaseExtension( IN PHSE psExt)
{
// decrement ref count and remove from table if needed
if ( !psExt->Dereference()) {
if ( psExt->IsCached())
{
RemoveFromList( psExt);
delete psExt;
}
else {
// non cached ISAPIs should be deleted (TerminateExtension
// call should be called) from a different thread because
// this thread could be an ISAPI thread (in case of pended
// ISAPI this could be the DONE_WITH_SESSION thread)
m_sesdExtensions.ScheduleExtensionForDeletion( psExt);
}
}
return;
} // SE_TABLE::ReleaseExtension()
APIERR
InitializeHseExtensions(
VOID
)
/*++
Routine Description:
Initializes the extension list cache
Return Value:
0 on success, win32 error on failure
--*/
{
DBGPRINTF(( DBG_CONTEXT, " InitExtensions() entered \n"));
DWORD err = NO_ERROR;
// UNDONE needs to move into wam.dll DllInit
if ( err == NO_ERROR ) {
// initialize other objects
g_psextensions = new SE_TABLE();
if ( (g_psextensions == NULL) ) {
err = (ERROR_NOT_ENOUGH_MEMORY);
if ( g_psextensions != NULL ) {
delete (g_psextensions);
g_psextensions = NULL;
}
} else {
g_fExtInitialized = TRUE;
}
}
DBGPRINTF(( DBG_CONTEXT, " Leaving InitExtensions().\n" ));
return ( err);
} // InitializeHseExtensions()
VOID
CleanupHseExtensions(
VOID
)
/*++
Routine Description:
Walks list and unloads each extension. No clients should be in an
extension at this point
--*/
{
DWORD i;
DBGPRINTF(( DBG_CONTEXT, " TerminateExtensions() called \n"
));
if ( !g_fExtInitialized )
return;
DBG_ASSERT( g_psextensions != NULL);
delete g_psextensions;
return;
} // CleanupHseExtensions()
/************************ End of File ***********************/
Reference in a new issue Copy permalink