1805 lines
53 KiB
C++
1805 lines
53 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: class.cxx
|
|
//
|
|
// Contents: Server table entry implementation
|
|
//
|
|
// History: VinayKr Created
|
|
// 06-Nov-98 TarunA Launch and shutdown logic change
|
|
// 24-Feb-99 TarunA Fix custom surrogate launch
|
|
// 17-Jun-99 a-sergiv Support for filtering RPCSS event logs
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "act.hxx"
|
|
|
|
CServerTable * gpClassTable = NULL;
|
|
CServerTable * gpProcessTable = NULL;
|
|
|
|
CSharedLock * gpClassLock = 0;
|
|
CSharedLock * gpProcessLock = 0;
|
|
|
|
CInterlockedInteger gRegisterKey( 1 );
|
|
|
|
//
|
|
// Default number of milliseconds to wait for a server to register its
|
|
// class factory before giving up and forcefully terminating it.
|
|
//
|
|
DWORD gServerStartTimeout = 120000;
|
|
|
|
//
|
|
// Default number of milliseconds to wait for a class factory registration
|
|
// after we detect that the launched server has died (for supporting cases
|
|
// where the server we launch turns around and launches another, then dies
|
|
// immediately)
|
|
//
|
|
DWORD gServerStartSecondChanceTimeout = 30000;
|
|
|
|
//
|
|
// Default number of milliseconds to wait for an NT service server to register
|
|
// before we wake up and query its status. At most we wait for
|
|
// gNTServiceMaxTimeouts of these periods (see code in WaitForService below).
|
|
//
|
|
DWORD gNTServiceInterrogatePeriod = 30000;
|
|
DWORD gNTServiceMaxTimeouts = 4;
|
|
|
|
//
|
|
// Default number of milliseconds that we block while waiting for a dllhost
|
|
// server to register. There is a startup protocol here - we block for
|
|
// thirty seconds, then check the state of the launched process.
|
|
//
|
|
DWORD gDllhostServerStartTimeout = 30000;
|
|
|
|
//
|
|
// Maxiumum number of milliseconds we will wait while waiting for a dllhost
|
|
// server to register. There is a protocol yes, but this is the upper time
|
|
// bound no matter what.
|
|
//
|
|
DWORD gDllhostMaxServerStartTimeout = 90000;
|
|
|
|
//
|
|
// Default number of milliseconds to wait for a dllhost to finish
|
|
// long-running initialization.
|
|
//
|
|
DWORD gDllhostInitializationTimeout = 90000;
|
|
|
|
void GetSessionIDFromActParams(IActivationPropertiesIn* pActPropsIn, LONG* plSessionID)
|
|
{
|
|
*plSessionID = INVALID_SESSION_ID;
|
|
|
|
if (pActPropsIn != NULL)
|
|
{
|
|
ISpecialSystemProperties *pSp = NULL;
|
|
HRESULT hr;
|
|
|
|
hr = pActPropsIn->QueryInterface(IID_ISpecialSystemProperties, (void**) &pSp);
|
|
if (SUCCEEDED(hr) && pSp != NULL)
|
|
{
|
|
ULONG ulSessionID;
|
|
BOOL bUseConsole;
|
|
|
|
hr = pSp->GetSessionId(&ulSessionID, &bUseConsole);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!bUseConsole && (ulSessionID != INVALID_SESSION_ID))
|
|
{
|
|
// Just use whatever was there
|
|
*plSessionID = (LONG) ulSessionID;
|
|
}
|
|
else if (bUseConsole)
|
|
{
|
|
// Little bit of magic here regarding how to find the
|
|
// currently active NT console session ID.
|
|
*plSessionID = (USER_SHARED_DATA->ActiveConsoleId);
|
|
}
|
|
}
|
|
|
|
pSp->Release();
|
|
pSp = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTable::GetOrCreate
|
|
//
|
|
// A somewhat degenerate combination of Lookup and Create -- only creates
|
|
// empty entries -- in particular without hooking up process entry if the
|
|
// entry being created is a class entry -- used only to create process entries
|
|
// and to create class entries for unsolicited CoRegisterClassObject calls
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerTableEntry *
|
|
CServerTable::GetOrCreate(
|
|
IN GUID & ServerGuid
|
|
)
|
|
{
|
|
CServerTableEntry * pEntry;
|
|
|
|
pEntry = Lookup( ServerGuid );
|
|
|
|
if ( pEntry )
|
|
return pEntry;
|
|
else
|
|
return Create(ServerGuid);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTable::Create
|
|
//
|
|
// Creates a new CServerTableEntry, or returns an existing one.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerTableEntry *
|
|
CServerTable::Create(
|
|
IN GUID & ServerGuid
|
|
)
|
|
{
|
|
BOOL fEntryFoundInTable = FALSE;
|
|
|
|
_pServerTableLock->LockExclusive();
|
|
|
|
// Must use CGuidTable::Lookup method because it doesn't take
|
|
// a shared lock. Already have the exclusive lock.
|
|
CServerTableEntry *pNewEntry = (CServerTableEntry *) CGuidTable::Lookup( &ServerGuid );
|
|
|
|
if (pNewEntry)
|
|
{
|
|
pNewEntry->Reference(); // Found an entry, take a reference on it
|
|
fEntryFoundInTable = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LONG Status;
|
|
pNewEntry = new CServerTableEntry( Status, &ServerGuid, _EntryType );
|
|
|
|
if ( ! pNewEntry )
|
|
{
|
|
_pServerTableLock->UnlockExclusive();
|
|
return NULL;
|
|
}
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
{
|
|
_pServerTableLock->UnlockExclusive();
|
|
// release using base class method because the entry is not
|
|
// in the table yet and we don't want to try to remove it
|
|
pNewEntry->CReferencedObject::Release();
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (!fEntryFoundInTable)
|
|
{
|
|
Add( pNewEntry );
|
|
}
|
|
|
|
_pServerTableLock->UnlockExclusive();
|
|
return pNewEntry;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTable::Lookup
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerTableEntry *
|
|
CServerTable::Lookup(
|
|
IN GUID & ServerGuid
|
|
)
|
|
{
|
|
CServerTableEntry * pServerTableEntry;
|
|
|
|
_pServerTableLock->LockShared();
|
|
pServerTableEntry = (CServerTableEntry *) CGuidTable::Lookup( &ServerGuid );
|
|
if ( pServerTableEntry )
|
|
pServerTableEntry->Reference();
|
|
_pServerTableLock->UnlockShared();
|
|
|
|
return pServerTableEntry;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::CServerTableEntry
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerTableEntry::CServerTableEntry(
|
|
OUT LONG& Status,
|
|
IN GUID * pServerGUID,
|
|
IN EnumEntryType EntryType
|
|
) :
|
|
CGuidTableEntry( pServerGUID ), _EntryType(EntryType)
|
|
,_ServerLock( Status ), _lThreadToken(0), _hProcess(0), _pProcess(NULL)
|
|
,_pvRunAsHandle(NULL), _bSuspendedClsid(FALSE), _bSuspendedApplication(FALSE),
|
|
_dwProcessId(0)
|
|
{
|
|
Status = ERROR_SUCCESS;
|
|
|
|
switch (_EntryType)
|
|
{
|
|
case ENTRY_TYPE_CLASS:
|
|
_pParentTable = gpClassTable;
|
|
break;
|
|
|
|
case ENTRY_TYPE_PROCESS:
|
|
_pParentTable = gpProcessTable;
|
|
break;
|
|
|
|
default:
|
|
Status = E_INVALIDARG;
|
|
}
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
_pParentTableLock = _pParentTable->_pServerTableLock;
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::~CServerTableEntry
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerTableEntry::~CServerTableEntry()
|
|
{
|
|
ASSERT(_pParentTableLock->HeldExclusive());
|
|
|
|
// Remove ourselves from the table
|
|
_pParentTable->Remove(this);
|
|
|
|
if(NULL != _pProcess)
|
|
{
|
|
ReleaseProcess(_pProcess);
|
|
}
|
|
|
|
ASSERT(_pvRunAsHandle == NULL);
|
|
ASSERT(_hProcess == NULL);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::Release
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
DWORD
|
|
CServerTableEntry::Release()
|
|
{
|
|
DWORD Refs;
|
|
CSharedLock* pParentTableLock = _pParentTableLock;
|
|
|
|
CairoleDebugOut((DEB_SCM, "Releasing ServerTableEntry at 0x%p\n", this));
|
|
|
|
pParentTableLock->LockExclusive();
|
|
|
|
Dereference();
|
|
if ( 0 == (Refs = References()) )
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
pParentTableLock->UnlockExclusive();
|
|
|
|
return Refs;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::RegisterServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT
|
|
CServerTableEntry::RegisterServer(
|
|
IN CProcess * pServerProcess,
|
|
IN IPID ipid,
|
|
IN CClsidData * pClsidData, OPTIONAL
|
|
IN CAppidData * pAppidData,
|
|
IN UCHAR ServerState,
|
|
OUT DWORD * pRegistrationKey )
|
|
{
|
|
CServerListEntry * pEntry;
|
|
CSurrogateListEntry * pSurrogateEntry;
|
|
|
|
UCHAR Context = 0;
|
|
UCHAR SubContext = 0;
|
|
|
|
if (pClsidData)
|
|
{
|
|
if ( (pClsidData->ServerType() == SERVERTYPE_SERVICE) ||
|
|
(pClsidData->ServerType() == SERVERTYPE_COMPLUS_SVC) )
|
|
{
|
|
Context = SERVER_SERVICE;
|
|
}
|
|
else if ( pClsidData->HasRunAs() )
|
|
{
|
|
Context = SERVER_RUNAS;
|
|
|
|
if ( pClsidData->IsInteractiveUser() )
|
|
SubContext = SUB_CONTEXT_RUNAS_INTERACTIVE;
|
|
else
|
|
SubContext = SUB_CONTEXT_RUNAS_THIS_USER;
|
|
}
|
|
// Special case of COM+ library class being loaded by VB for debugging
|
|
else if ( pClsidData->ServerType() == SERVERTYPE_COMPLUS && pClsidData->IsInprocClass() )
|
|
{
|
|
Context = SERVER_RUNAS;
|
|
}
|
|
}
|
|
|
|
if ( _EntryType == ENTRY_TYPE_PROCESS )
|
|
{
|
|
// This is the COM+/COM surrogate case
|
|
Win4Assert(NULL == pClsidData && "Process Entry Given Clsid data");
|
|
Win4Assert(NULL != pAppidData && "Process Entry Not Given Appid data");
|
|
if (pAppidData->Service())
|
|
{
|
|
Context = SERVER_SERVICE;
|
|
}
|
|
else if ((pAppidData->IsInteractiveUser()) || pAppidData->RunAsUser())
|
|
{
|
|
Context = SERVER_RUNAS;
|
|
}
|
|
}
|
|
|
|
// If none of the above applied, Context will be zero at this point -- this
|
|
// essentially means the server should be treated as an activate-as-activator
|
|
// server. However, if Context is zero SubContext had better also be zero,
|
|
// and so we assert that here.
|
|
if (Context == 0)
|
|
{
|
|
Context = SERVER_ACTIVATOR;
|
|
ASSERT(SubContext == 0);
|
|
}
|
|
|
|
pEntry = new CServerListEntry(
|
|
this,
|
|
pServerProcess,
|
|
ipid,
|
|
Context,
|
|
ServerState,
|
|
SubContext);
|
|
|
|
if ( ! pEntry )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Add registration to the process object -- but only if we are a class entry;
|
|
// otherwise this is a registration for a surrogate server
|
|
if ( _EntryType == ENTRY_TYPE_CLASS )
|
|
{
|
|
pEntry->AddToProcess( Guid() );
|
|
}
|
|
|
|
//
|
|
SetSuspendedFlagOnNewServer(pServerProcess);
|
|
|
|
//
|
|
// NOTE: The entry should be inserted in the lists only after
|
|
// all the registration specific stuff has been done. This will
|
|
// ensure that anyone outside this procedure sees the complete
|
|
// entry and not some half-baked one
|
|
//
|
|
|
|
ServerLock()->LockExclusive();
|
|
// Check if process handle exists implying that a
|
|
// launch is in progress for this class. Try to
|
|
// register runas,process, and threadtoken with
|
|
// the newly created entry
|
|
// Note that it is essential for the server lock to
|
|
// be held since _hProcess can change otherwise.
|
|
if (_hProcess || _pProcess)
|
|
RegisterHandles(pEntry, pServerProcess);
|
|
_ServerList.Insert( pEntry );
|
|
ServerLock()->UnlockExclusive();
|
|
|
|
//
|
|
// It's possible that a process could register itself as a surrogate but
|
|
// there's no CLSID info in the registry. We might want to disallow
|
|
// this kind of register.
|
|
//
|
|
// Note: We allow class registration if appid is not present but don't
|
|
// allow surrogate registration since it'll never be found
|
|
// The right thing to do would be to reject the call completely when
|
|
// an appid is not present but we will take the path of least resistance
|
|
// and preserve legacy
|
|
if ( pClsidData && (ServerState & SERVERSTATE_SURROGATE) && pClsidData->AppidString() )
|
|
{
|
|
pSurrogateEntry = new CSurrogateListEntry( pClsidData->AppidString(), pEntry );
|
|
|
|
if ( ! pSurrogateEntry )
|
|
{
|
|
pEntry->CReferencedObject::Release();
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
gpSurrogateList->Insert( pSurrogateEntry );
|
|
}
|
|
|
|
*pRegistrationKey = pEntry->RegistrationKey();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::RevokeServer -- version 1 for class entries
|
|
//
|
|
// CODE WORK: Consider defining two separate classes for class and
|
|
// process entries so we can avoid this sort of thing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void
|
|
CServerTableEntry::RevokeServer(
|
|
IN CProcess * pServerProcess,
|
|
IN DWORD RegistrationKey
|
|
)
|
|
{
|
|
Win4Assert(_EntryType == ENTRY_TYPE_CLASS);
|
|
|
|
ServerLock()->LockExclusive();
|
|
|
|
CServerListEntry * pEntry = (CServerListEntry *) _ServerList.First();
|
|
|
|
for ( ; pEntry; pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if ( (RegistrationKey == pEntry->_RegistrationKey)
|
|
#if 1 // #ifndef _CHICAGO_
|
|
&& (pServerProcess == pEntry->_pServerProcess)
|
|
#endif
|
|
)
|
|
break;
|
|
}
|
|
|
|
if ( pEntry )
|
|
_ServerList.Remove( pEntry );
|
|
|
|
ServerLock()->UnlockExclusive();
|
|
|
|
if ( pEntry )
|
|
{
|
|
pEntry->RemoveFromProcess();
|
|
pEntry->Release();
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::RevokeServer -- version 2 for process entries
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void
|
|
CServerTableEntry::RevokeServer(
|
|
IN ScmProcessReg * pScmProcessReg
|
|
)
|
|
{
|
|
Win4Assert(_EntryType == ENTRY_TYPE_PROCESS);
|
|
|
|
ServerLock()->LockExclusive();
|
|
|
|
CServerListEntry * pEntry = (CServerListEntry *) _ServerList.First();
|
|
|
|
for ( ; pEntry; pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if ( (pScmProcessReg->RegistrationToken == pEntry->_RegistrationKey)
|
|
)
|
|
break;
|
|
}
|
|
|
|
if ( pEntry )
|
|
_ServerList.Remove( pEntry );
|
|
|
|
ServerLock()->UnlockExclusive();
|
|
|
|
if ( pEntry )
|
|
{
|
|
pEntry->RemoveFromProcess();
|
|
pEntry->Release();
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::LookupServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL
|
|
CServerTableEntry::LookupServer(
|
|
IN CToken * pClientToken,
|
|
IN BOOL bRemoteActivation,
|
|
IN BOOL bClientImpersonating,
|
|
IN WCHAR * pwszWinstaDesktop,
|
|
IN DWORD dwFlags,
|
|
IN LONG lThreadToken,
|
|
IN LONG lSessionID,
|
|
IN DWORD pid,
|
|
IN DWORD dwProcessReqType,
|
|
OUT CServerListEntry ** ppServerListEntry)
|
|
{
|
|
CServerListEntry * pEntry;
|
|
|
|
*ppServerListEntry = NULL;
|
|
|
|
// If we are suspended, no need to go any further
|
|
if (IsSuspended())
|
|
return FALSE;
|
|
|
|
ServerLock()->LockShared();
|
|
|
|
pEntry = (CServerListEntry *) _ServerList.First();
|
|
|
|
for ( ; pEntry; pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if ( pEntry->Match( pClientToken,
|
|
bRemoteActivation,
|
|
bClientImpersonating,
|
|
pwszWinstaDesktop,
|
|
FALSE,
|
|
lThreadToken,
|
|
lSessionID,
|
|
pid,
|
|
dwProcessReqType,
|
|
dwFlags ) )
|
|
{
|
|
pEntry->Reference();
|
|
break;
|
|
}
|
|
}
|
|
|
|
ServerLock()->UnlockShared();
|
|
|
|
*ppServerListEntry = pEntry;
|
|
return (pEntry != 0);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::LookupServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL
|
|
CServerTableEntry::LookupServer(
|
|
IN DWORD RegistrationKey,
|
|
CServerListEntry ** ppServerListEntry )
|
|
{
|
|
CServerListEntry * pEntry;
|
|
|
|
ServerLock()->LockShared();
|
|
|
|
pEntry = (CServerListEntry *) _ServerList.First();
|
|
|
|
for ( ; pEntry; pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if ( RegistrationKey == pEntry->_RegistrationKey )
|
|
break;
|
|
}
|
|
|
|
if ( pEntry )
|
|
pEntry->Reference();
|
|
|
|
ServerLock()->UnlockShared();
|
|
|
|
*ppServerListEntry = pEntry;
|
|
return (pEntry != 0);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::UnsuspendServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void
|
|
CServerTableEntry::UnsuspendServer(
|
|
IN DWORD RegistrationKey
|
|
)
|
|
{
|
|
CServerListEntry * pEntry;
|
|
|
|
LookupServer( RegistrationKey, &pEntry );
|
|
|
|
if ( pEntry )
|
|
{
|
|
pEntry->_State &= ~SERVERSTATE_SUSPENDED;
|
|
pEntry->Release();
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// CServerTableEntry::ServerExists
|
|
//+-------------------------------------------------------------------------
|
|
HRESULT
|
|
CServerTableEntry::ServerExists(
|
|
IN ACTIVATION_PARAMS * pActParams, BOOL *pfExist)
|
|
{
|
|
LONG lSessionID = INVALID_SESSION_ID;
|
|
ServerLock()->LockShared();
|
|
|
|
GetSessionIDFromActParams(pActParams->pActPropsIn, &lSessionID);
|
|
|
|
CServerListEntry *pEntry = (CServerListEntry *) _ServerList.First();
|
|
|
|
for ( ; pEntry; pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if ( pEntry->Match(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->bClientImpersonating,
|
|
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL ,
|
|
FALSE,
|
|
0,
|
|
lSessionID ))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
ServerLock()->UnlockShared();
|
|
|
|
*pfExist = (pEntry != NULL);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::CallRunningServer
|
|
// Synopsis: The behavior of CallRunningServer is best described by this matrix
|
|
//
|
|
// If the call is made successfully then we return
|
|
// If CallServer() returns error then we take the following action
|
|
// ----------------------------------------------------------------------------
|
|
// | | RPC_E_SERVERFAULT | CO_E_SERVER_STOPPING | Other Errors |
|
|
// ----------------------------------------------------------------------------
|
|
// | COM | Kill the process | Remove the list entry |Remove the list entry|
|
|
// | | Remove the list entry | Try launching another |Try launching another|
|
|
// | | Try launching another | process |process |
|
|
// | | process | | |
|
|
// | | | | |
|
|
// -----------------------------------------------------------------------------
|
|
// | COM+| Kill the process | Set a timeout period |If process exists |
|
|
// | | Remove the list entry | If the server |then |
|
|
// | | Return the error | stops before timeout | return error |
|
|
// | | | then |else |
|
|
// | | | try launching | Remove the entry |
|
|
// | | | another process | try launching |
|
|
// | | | else | another process |
|
|
// | | | return error | |
|
|
// -----------------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------------
|
|
BOOL
|
|
CServerTableEntry::CallRunningServer(
|
|
IN ACTIVATION_PARAMS * pActParams,
|
|
IN DWORD dwFlags,
|
|
IN LONG lLaunchThreadToken,
|
|
IN CClsidData * pClsidData,
|
|
OUT HRESULT * phr
|
|
)
|
|
{
|
|
BOOL bStatus;
|
|
LONG lSessionID = INVALID_SESSION_ID;
|
|
CServerListEntry* pEntry;
|
|
|
|
GetSessionIDFromActParams(pActParams->pActPropsIn, &lSessionID);
|
|
|
|
for (;;)
|
|
{
|
|
BOOL bTerminatedServer;
|
|
|
|
bStatus = LookupServer(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->bClientImpersonating,
|
|
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL ,
|
|
dwFlags,
|
|
lLaunchThreadToken,
|
|
lSessionID,
|
|
pActParams->dwPID,
|
|
pActParams->dwProcessReqType,
|
|
&pEntry);
|
|
if (!bStatus)
|
|
{
|
|
Win4Assert(!pEntry);
|
|
return FALSE;
|
|
}
|
|
|
|
*phr = S_OK;
|
|
|
|
//
|
|
// If the entry is "initializing", then it isn't really ready yet.
|
|
// Wait for it to become so.
|
|
//
|
|
if (pEntry->IsInitializing())
|
|
{
|
|
*phr = WaitForInitCompleted(pEntry, pClsidData);
|
|
if (FAILED(*phr))
|
|
{
|
|
if (*phr == CO_E_SERVER_STOPPING)
|
|
bStatus = FALSE;
|
|
else
|
|
bStatus = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Returns TRUE if we successfully make a call to this server, or
|
|
// if an unrecoverable non-server-related error is encountered
|
|
// (e.g, an out-of-mem failure while allocating data before or
|
|
// after the call).
|
|
//
|
|
// The final HRESULT is not necessarily S_OK.
|
|
//
|
|
if (SUCCEEDED(*phr))
|
|
bStatus = pEntry->CallServer(pActParams, phr);
|
|
if (!bStatus)
|
|
{
|
|
// We were unable to talk to the server, or got back
|
|
// CO_E_SERVER_STOPPING.
|
|
|
|
// Retrieve the process handle, if we have one
|
|
HANDLE hProcess = pEntry->GetProcess()->GetProcessHandle();
|
|
|
|
bTerminatedServer = FALSE;
|
|
|
|
// Try to kill the server if it returned RPC_E_SERVERFAULT (this
|
|
// means that we caught an unhandled exception somewhere in the
|
|
// server, which we don't really appreciate.)
|
|
if(*phr == RPC_E_SERVERFAULT)
|
|
{
|
|
if(hProcess)
|
|
{
|
|
bTerminatedServer = TerminateProcess(hProcess, 0);
|
|
}
|
|
|
|
// Remember that the server blew up on us. This is mostly
|
|
// for debugging purposes
|
|
pEntry->IncServerFaults();
|
|
}
|
|
|
|
//
|
|
// Determine if we need to remove the server entry. We will do this if
|
|
// a) we killed the server process up above; or b) the server returned
|
|
// CO_E_SERVER_STOPPING; or c) the server process is dead already.
|
|
//
|
|
if (bTerminatedServer ||
|
|
(*phr == CO_E_SERVER_STOPPING) ||
|
|
pEntry->ServerDied())
|
|
{
|
|
BOOL bRemoved;
|
|
|
|
//
|
|
// Remove this server entry if it's still in the list.
|
|
//
|
|
ServerLock()->LockExclusive();
|
|
|
|
bRemoved = _ServerList.InList(pEntry);
|
|
if (bRemoved)
|
|
_ServerList.Remove(pEntry);
|
|
|
|
ServerLock()->UnlockExclusive();
|
|
|
|
if (bRemoved)
|
|
{
|
|
pEntry->RemoveFromProcess();
|
|
pEntry->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now allow threads other than launching one to access
|
|
// this entry. Exit since we matched launched server
|
|
// regardless of result since we know that we will
|
|
// not get any more matches.
|
|
if (lLaunchThreadToken)
|
|
{
|
|
pEntry->SetThreadToken(0);
|
|
pEntry->Release();
|
|
return bStatus;
|
|
}
|
|
|
|
pEntry->Release();
|
|
|
|
if ( bStatus )
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::StartServerAndWait
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT
|
|
CServerTableEntry::StartServerAndWait(
|
|
IN ACTIVATION_PARAMS * pActParams,
|
|
IN CClsidData * pClsidData,
|
|
IN LONG &lLaunchThreadToken
|
|
)
|
|
{
|
|
SC_HANDLE hService;
|
|
HRESULT hr;
|
|
BOOL bStatus;
|
|
BOOL bServiceAlreadyRunning = FALSE;
|
|
DWORD dwActvFlags;
|
|
|
|
if ( ! pClsidData->LaunchAllowed( pActParams->pToken, pActParams->ClsContext ) )
|
|
return E_ACCESSDENIED;
|
|
|
|
// Check CreateProcessMemoryGate
|
|
// [a-sergiv (Sergei O. Ivanov) 11/1/99 Implemented Memory Gates in COM Base
|
|
if(pActParams->pActPropsIn)
|
|
{
|
|
BOOL bResult = TRUE;
|
|
IClassClassicInfo *pClassicInfo = NULL;
|
|
hr = pActParams->pActPropsIn->GetClassInfo(IID_IClassClassicInfo, (void**) &pClassicInfo);
|
|
|
|
if(SUCCEEDED(hr) && pClassicInfo)
|
|
{
|
|
IResourceGates *pResGates = NULL;
|
|
hr = pClassicInfo->GetProcess(IID_IResourceGates, (void**) &pResGates);
|
|
pClassicInfo->Release();
|
|
|
|
if(SUCCEEDED(hr) && pResGates)
|
|
{
|
|
hr = pResGates->Test(CreateProcessMemoryGate, &bResult);
|
|
pResGates->Release();
|
|
|
|
if(SUCCEEDED(hr) && !bResult)
|
|
{
|
|
// The gate said NO!
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
hService = 0;
|
|
|
|
// NOTE: _hProcess, _dwProcessId, _pProcess and all other process specific
|
|
// variables that are part of CServerTableEntry are used only during the
|
|
// launch. Once the launch is completed either they are transferred to
|
|
// process specific entries or discarded. See CServerTableEntry::RegisterHandles
|
|
// for an example.
|
|
_dwProcessId = 0;
|
|
|
|
// _hProcess and _pProcess variables are released and set to
|
|
// null whether
|
|
// (1) This is the first launch
|
|
// OR
|
|
// (2) We succeeded in an earlier launch or failed
|
|
Win4Assert((0 == _hProcess) && (NULL == _pProcess));
|
|
|
|
//
|
|
// Get the register event for the server we're about to launch. Note
|
|
// there exists a problem in that we may launch a server, but another
|
|
// server may register the desired clsid\appid at about the same time.
|
|
// I think this is just something we have to live with, especially since
|
|
// there are servers in the world that don't register with us, but instead
|
|
// turn around and launch another process to do the registration. So,
|
|
// even if we have a process handle it would be impossible to always
|
|
// correlate from register event back to the launching table entry.
|
|
//
|
|
HANDLE hRegisterEvent = pClsidData->ServerRegisterEvent();
|
|
if (!hRegisterEvent)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (pClsidData->ServerType() == SERVERTYPE_SURROGATE)
|
|
{
|
|
Win4Assert(_EntryType == ENTRY_TYPE_CLASS);
|
|
|
|
LPWSTR pwszAppidString = pClsidData->AppidString();
|
|
CSurrogateListEntry * pSurrogateListEntry = NULL;
|
|
|
|
if(pwszAppidString)
|
|
{
|
|
pSurrogateListEntry = gpSurrogateList->Lookup(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->bClientImpersonating,
|
|
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL ,
|
|
pwszAppidString );
|
|
}
|
|
|
|
if ( pSurrogateListEntry )
|
|
{
|
|
// If we find a surrogate entry and we are inside a launch
|
|
// server then that implies that a surrogate was launched for
|
|
// a different class' activation. We have a process entry for
|
|
// this surrogate and we set it here. Later when RegisterServer
|
|
// gets called we use the process object to set the state.
|
|
// For all other cases, the state is set using the process handle.
|
|
_pProcess = pSurrogateListEntry->Process();
|
|
Win4Assert(NULL !=_pProcess);
|
|
// We will release this on every path below
|
|
ReferenceProcess( _pProcess, TRUE );
|
|
|
|
// Remember the launching thread's token
|
|
_lThreadToken = lLaunchThreadToken;
|
|
|
|
// Load the dll that will service the activation request
|
|
bStatus = pSurrogateListEntry->LoadDll( pActParams, &hr );
|
|
pSurrogateListEntry->Release();
|
|
|
|
// A status of TRUE implies that we successfully talked to the
|
|
// server
|
|
if (bStatus)
|
|
{
|
|
// A successful hresult implies that the server was able to
|
|
// load the dll successfully and hence we expect it to
|
|
// register back
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
// Wait for the loaded object server to register back
|
|
bStatus = WaitForSingleObject( hRegisterEvent, 30000 );
|
|
}
|
|
// If the server failed to load the dll or it registered back
|
|
// within the timeout then we return immediately
|
|
if ( FAILED(hr) || (bStatus == WAIT_OBJECT_0) )
|
|
{
|
|
ReleaseProcess(_pProcess);
|
|
_pProcess = NULL;
|
|
CloseHandle(hRegisterEvent);
|
|
return hr;
|
|
}
|
|
}
|
|
// If a launched server failed to register back in the given
|
|
// timeout or we were not able to talk to the server then we
|
|
// continue and try to launch a new process
|
|
ReleaseProcess(_pProcess);
|
|
_pProcess = NULL;
|
|
}
|
|
}
|
|
|
|
if ((pClsidData->ServerType() == SERVERTYPE_SERVICE) ||
|
|
(pClsidData->ServerType() == SERVERTYPE_COMPLUS_SVC))
|
|
{
|
|
#ifndef _CHICAGO_
|
|
// Set the token here as service does not register back
|
|
// with us and so it cannot be set at registration time
|
|
// unlike the activator server case below
|
|
|
|
hr = pClsidData->LaunchService( pActParams->pToken, pActParams->ClsContext, &hService );
|
|
|
|
if (hr == HRESULT_FROM_WIN32(ERROR_SERVICE_ALREADY_RUNNING))
|
|
{
|
|
hr = S_OK;
|
|
bServiceAlreadyRunning = TRUE;
|
|
}
|
|
#endif // _CHICAGO_
|
|
}
|
|
else
|
|
{
|
|
//When a "RunAs Interactive User" server is launched from a Hydra session,
|
|
//the server runs in the Hydra session of the caller. In this case,
|
|
//we want to call LaunchActivator server instead of LaunchRunAsServer
|
|
//so that the server runs in the appropriate Hydra session.
|
|
|
|
//if ( pClsidData->HasRunAs() &&
|
|
// (!pClsidData->IsInteractiveUser() || !pActParams->pToken ||!pActParams->pToken->GetSessionId()))
|
|
|
|
_lThreadToken = lLaunchThreadToken;
|
|
|
|
if ( pClsidData->HasRunAs())
|
|
{
|
|
#ifndef _CHICAGO_
|
|
hr = pClsidData->LaunchRunAsServer(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->pActPropsIn,
|
|
pActParams->ClsContext,
|
|
&_hProcess,
|
|
&_dwProcessId,
|
|
&_pvRunAsHandle);
|
|
#endif // _CHICAGO_
|
|
}
|
|
else
|
|
{
|
|
// Check to see if the client requested "protected" activation. If
|
|
// so, we refuse to launch a server using their token.
|
|
hr = pActParams->pActPropsIn->GetActivationFlags(&dwActvFlags);
|
|
|
|
if (FAILED(hr) || (dwActvFlags & ACTVFLAGS_DISABLE_AAA))
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pClsidData->LaunchActivatorServer(
|
|
pActParams->pToken,
|
|
pActParams->pEnvBlock,
|
|
pActParams->EnvBlockLength,
|
|
pActParams->RemoteActivation,
|
|
pActParams->bClientImpersonating,
|
|
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL,
|
|
pActParams->ClsContext,
|
|
&_hProcess,
|
|
&_dwProcessId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
#ifndef _CHICAGO_
|
|
Win4Assert(_pvRunAsHandle == NULL);
|
|
#endif
|
|
_lThreadToken = 0;
|
|
CloseHandle(hRegisterEvent);
|
|
return hr;
|
|
}
|
|
|
|
|
|
// we got this far so it is time to wait for the server/service we just
|
|
// launched to register itself with us appropriately and in a timely fashion
|
|
|
|
// Retry once if we fail to get desktop resources the first time
|
|
BOOL fSuccessful;
|
|
for (int i=0; i<2; i++) {
|
|
|
|
ULONG winerr=0;
|
|
fSuccessful = FALSE;
|
|
|
|
switch (pClsidData->ServerType())
|
|
{
|
|
case SERVERTYPE_SERVICE:
|
|
case SERVERTYPE_COMPLUS_SVC:
|
|
Win4Assert(hService && "Waiting for service with NULL handle");
|
|
fSuccessful = WaitForService(hService, hRegisterEvent,
|
|
bServiceAlreadyRunning);
|
|
CloseServiceHandle( hService );
|
|
hService = 0;
|
|
break;
|
|
|
|
case SERVERTYPE_COMPLUS:
|
|
case SERVERTYPE_DLLHOST:
|
|
fSuccessful = WaitForDllhostServer(hRegisterEvent,
|
|
pActParams,
|
|
winerr,
|
|
lLaunchThreadToken);
|
|
break;
|
|
|
|
default:
|
|
fSuccessful = WaitForLocalServer(hRegisterEvent,
|
|
winerr);
|
|
break;
|
|
}
|
|
|
|
#ifndef _CHICAGO_
|
|
if ( (i==0) && _pvRunAsHandle && (!fSuccessful ) &&
|
|
(winerr == ERROR_WAIT_NO_CHILDREN))
|
|
{
|
|
RunAsInvalidateAndRelease(_pvRunAsHandle);
|
|
_pvRunAsHandle = NULL;
|
|
hr = pClsidData->LaunchRunAsServer(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->pActPropsIn,
|
|
pActParams->ClsContext,
|
|
&_hProcess,
|
|
&_dwProcessId,
|
|
&_pvRunAsHandle);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
Win4Assert(_pvRunAsHandle == NULL);
|
|
CloseHandle(hRegisterEvent);
|
|
return hr;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
#endif // _CHICAGO_
|
|
|
|
break;
|
|
}
|
|
|
|
if ( !fSuccessful )
|
|
{
|
|
GUID ServerGuid = Guid();
|
|
LogRegisterTimeout( &ServerGuid, pActParams->ClsContext, pActParams->pToken );
|
|
hr = CO_E_SERVER_EXEC_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
// Ensure that we are serializing around
|
|
// registration which takes an exclusive
|
|
// before modifying this and is the only
|
|
// one that needs to look at or modify it.
|
|
if (_hProcess)
|
|
{
|
|
|
|
ServerLock()->LockShared();
|
|
|
|
if (_hProcess)
|
|
{
|
|
CloseHandle(_hProcess);
|
|
_hProcess = 0;
|
|
}
|
|
|
|
ServerLock()->UnlockShared();
|
|
|
|
}
|
|
|
|
|
|
// If we still have the token set the callers also to
|
|
// NULL because we might have succeeded the launch but
|
|
// the server registering back was different from
|
|
// the one launched(this should be very rare).
|
|
if (_lThreadToken)
|
|
{
|
|
_lThreadToken = 0;
|
|
lLaunchThreadToken = 0;
|
|
}
|
|
|
|
#ifndef _CHICAGO_
|
|
if (_pvRunAsHandle)
|
|
{
|
|
Win4Assert(pClsidData->HasRunAs());
|
|
RunAsRelease(_pvRunAsHandle);
|
|
_pvRunAsHandle = NULL;
|
|
}
|
|
#endif // _CHICAGO_
|
|
|
|
CloseHandle(hRegisterEvent);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::RegisterHandles
|
|
//
|
|
// Synopsis Register either the RunAs or the process handle with the
|
|
// CProcess object. Also register Single use Thread token.
|
|
//
|
|
// NOTE: this is called by RegisterServer
|
|
//--------------------------------------------------------------------------
|
|
BOOL CServerTableEntry::RegisterHandles(IN CServerListEntry * pEntry,
|
|
IN CProcess *pServerProcess)
|
|
{
|
|
BOOL bStatus = TRUE;
|
|
|
|
// Are we interested in registering the process handle
|
|
if(_hProcess || _pProcess)
|
|
{
|
|
Win4Assert(pServerProcess);
|
|
// We can have either a process handle if this entry is the one
|
|
// which was the first to launch the server or we can have a process
|
|
// object if the server has already been launched. The two cases are
|
|
// mutually exclusive and we assert that here.
|
|
Win4Assert((_hProcess && (NULL == _pProcess)) ||
|
|
(0 == _hProcess && (NULL != _pProcess)));
|
|
if(_hProcess)
|
|
bStatus = pServerProcess->SetProcessHandle(_hProcess,_dwProcessId);
|
|
|
|
// If a FALSE status is returned then the PID of the process launched
|
|
// by us did not match the PID of the process registered.
|
|
// The only cases where this will be FALSE are if a server is
|
|
// started by hand at the same time as a system launch or the
|
|
// process registering was launched by the one we launched.
|
|
// This should almost never happen
|
|
if (!bStatus)
|
|
goto ExitRegisterHandles;
|
|
|
|
// If the PID matched then we are sure that this register event
|
|
// matches the server we launched
|
|
|
|
// Given process handle away so remove our reference
|
|
_hProcess = 0;
|
|
|
|
// If we had a process match save thread token if
|
|
// it was passed since this thread launched the server
|
|
if (_lThreadToken)
|
|
{
|
|
pEntry->SetThreadToken(_lThreadToken);
|
|
_lThreadToken = NULL;
|
|
}
|
|
|
|
// Are we interested in registering the RunAs handle ?
|
|
#ifndef _CHICAGO_
|
|
if (_pvRunAsHandle)
|
|
{
|
|
// Pass our winsta reference over to process entry which will
|
|
// release it when it goes away so we can be rid of
|
|
// responsibilities for it.
|
|
RunAsSetWinstaDesktop(_pvRunAsHandle,
|
|
pServerProcess->WinstaDesktop());
|
|
pServerProcess->SetRunAsHandle(_pvRunAsHandle);
|
|
|
|
// Given Handle away so remove our reference
|
|
_pvRunAsHandle = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
ExitRegisterHandles:
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::WaitForLocalServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
BOOL
|
|
CServerTableEntry::WaitForLocalServer(
|
|
IN HANDLE hRegisterEvent,
|
|
IN ULONG &winerr
|
|
)
|
|
{
|
|
DWORD Status = WAIT_OBJECT_0+1;
|
|
BOOL bStatus = FALSE;
|
|
|
|
HANDLE Handles[2];
|
|
|
|
Handles[0] = hRegisterEvent;
|
|
Handles[1] = _hProcess;
|
|
|
|
// Wait for process and register events
|
|
Status = WaitForMultipleObjects( 2, Handles, FALSE, gServerStartTimeout );
|
|
|
|
if ( Status == (WAIT_OBJECT_0 + 1) )
|
|
{
|
|
// Launched Process went away but this could be the case
|
|
// where we have a launched server that starts another server
|
|
// which registers back(Lotus or something ??)
|
|
// So null the handle and wait for the register event for
|
|
// a much shorter time
|
|
GetExitCodeProcess(_hProcess, &winerr);
|
|
|
|
HANDLE hProcess;
|
|
|
|
CloseHandle( _hProcess );
|
|
_hProcess = 0;
|
|
|
|
Status = WaitForSingleObject( hRegisterEvent, gServerStartSecondChanceTimeout );
|
|
}
|
|
|
|
if ( Status != WAIT_OBJECT_0 && _hProcess )
|
|
TerminateProcess( _hProcess, 0 );
|
|
|
|
if ( Status == WAIT_OBJECT_0 )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::WaitForDllhostServer
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CServerTableEntry::WaitForDllhostServer(
|
|
IN HANDLE hRegisterEvent,
|
|
IN ACTIVATION_PARAMS *pActParams,
|
|
IN ULONG &winerr,
|
|
IN LONG lThreadToken
|
|
)
|
|
{
|
|
DWORD Status = WAIT_OBJECT_0+1;
|
|
DWORD WaitedMilliSecondsToStart = 0;
|
|
|
|
CServerListEntry * pEntry = NULL;
|
|
BOOL bStatus;
|
|
CProcess *pProcess=NULL;
|
|
|
|
HANDLE Handles[2];
|
|
|
|
Handles[0] = hRegisterEvent;
|
|
Handles[1] = _hProcess;
|
|
|
|
LONG lSessionID = INVALID_SESSION_ID;
|
|
GetSessionIDFromActParams(pActParams->pActPropsIn, &lSessionID);
|
|
|
|
for (;;)
|
|
{
|
|
// Wait for process and register events
|
|
Status = WaitForMultipleObjects( 2, Handles,
|
|
FALSE, gDllhostServerStartTimeout );
|
|
|
|
if ( ( Status == WAIT_OBJECT_0 ) ||
|
|
( Status == (WAIT_OBJECT_0 + 1 )))
|
|
break;
|
|
|
|
if (pEntry == NULL)
|
|
{
|
|
bStatus = LookupServer(
|
|
pActParams->pToken,
|
|
pActParams->RemoteActivation,
|
|
pActParams->bClientImpersonating,
|
|
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL ,
|
|
MATCHFLAG_ALLOW_SUSPENDED, // Dllhost is suspended now, we still want to find it!
|
|
lThreadToken,
|
|
lSessionID,
|
|
0, // no need for a pid here
|
|
PRT_IGNORE, // no need for prt here
|
|
&pEntry);
|
|
|
|
if (!bStatus)
|
|
pEntry = NULL;
|
|
else
|
|
{
|
|
pProcess = pEntry->_pServerProcess;
|
|
Win4Assert(pProcess != NULL);
|
|
}
|
|
}
|
|
|
|
ScmProcessReg *pScmProcessReg=NULL;
|
|
if (pProcess)
|
|
{
|
|
pScmProcessReg = pProcess->GetProcessReg();
|
|
Win4Assert(pScmProcessReg != NULL);
|
|
}
|
|
|
|
if (! pScmProcessReg )
|
|
{
|
|
// ProcessActivatorStarted not called yet
|
|
WaitedMilliSecondsToStart += gDllhostServerStartTimeout;
|
|
if (WaitedMilliSecondsToStart >= gDllhostMaxServerStartTimeout)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
// ProcessActivatorStarted has been called, how long since last call from
|
|
// initial process activator?
|
|
|
|
// handles wraparound
|
|
CTime CurrentTime;
|
|
DWORD WaitedMilliSecondsToReady = CurrentTime - pScmProcessReg->TimeOfLastPing;
|
|
|
|
if (WaitedMilliSecondsToReady >= gDllhostMaxServerStartTimeout)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
if (pEntry)
|
|
pEntry->Release();
|
|
|
|
if ( Status == WAIT_OBJECT_0 )
|
|
return TRUE;
|
|
else
|
|
{
|
|
GetExitCodeProcess(_hProcess, &winerr);
|
|
TerminateProcess( _hProcess, 0 );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::WaitForService
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CServerTableEntry::WaitForService(
|
|
IN SC_HANDLE hService,
|
|
IN HANDLE hRegisterEvent,
|
|
IN BOOL bServiceAlreadyRunning
|
|
)
|
|
{
|
|
SERVICE_STATUS ServiceStatus;
|
|
DWORD Status;
|
|
BOOL bStatus;
|
|
BOOL bKeepLooping;
|
|
BOOL bStopService = FALSE;
|
|
|
|
for (DWORD i = 0; i < gNTServiceMaxTimeouts; i++)
|
|
{
|
|
Status = WaitForSingleObject( hRegisterEvent, gNTServiceInterrogatePeriod );
|
|
if (Status == WAIT_OBJECT_0)
|
|
{
|
|
// register event was signalled, just return
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Assume we are done
|
|
bKeepLooping = FALSE;
|
|
|
|
bStatus = ControlService( hService,
|
|
SERVICE_CONTROL_INTERROGATE,
|
|
&ServiceStatus );
|
|
if (bStatus)
|
|
{
|
|
switch ( ServiceStatus.dwCurrentState )
|
|
{
|
|
case SERVICE_STOPPED :
|
|
case SERVICE_STOP_PENDING :
|
|
// weirdness
|
|
break;
|
|
|
|
case SERVICE_RUNNING :
|
|
case SERVICE_START_PENDING :
|
|
case SERVICE_CONTINUE_PENDING :
|
|
// the service is taking its own sweet time. Keep
|
|
// looping to give it more time.
|
|
bKeepLooping = TRUE;
|
|
break;
|
|
|
|
case SERVICE_PAUSE_PENDING :
|
|
case SERVICE_PAUSED :
|
|
// more weirdness
|
|
if (!bServiceAlreadyRunning)
|
|
bStopService = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
//else quit
|
|
|
|
if (!bKeepLooping)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bStopService )
|
|
{
|
|
(void) ControlService( hService,
|
|
SERVICE_CONTROL_STOP,
|
|
&ServiceStatus );
|
|
}
|
|
|
|
if ( Status == WAIT_OBJECT_0 )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::WaitForInitCompleted
|
|
//
|
|
// Wait for an initializing server (dllhost) to finish initialization.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT
|
|
CServerTableEntry::WaitForInitCompleted(
|
|
IN CServerListEntry *pEntry,
|
|
IN CClsidData *pClsidData
|
|
)
|
|
{
|
|
Win4Assert(pClsidData); // Should NOT call this without registration info.
|
|
if (NULL == pClsidData)
|
|
{
|
|
// If no clsid data, then we'll just need to return the
|
|
// "I'm initializing still" error code, since we have no
|
|
// way of waiting. I don't think this should ever happen,
|
|
// though.
|
|
return CO_E_SERVER_INIT_TIMEOUT;
|
|
}
|
|
|
|
HANDLE hInitEvent = pClsidData->ServerInitializedEvent();
|
|
if (!hInitEvent)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
if (pEntry->IsInitializing())
|
|
{
|
|
HANDLE hProcess = pEntry->_pServerProcess->GetProcessHandle();
|
|
|
|
DWORD dwRet;
|
|
if (hProcess)
|
|
{
|
|
HANDLE handles[2] = {hInitEvent, hProcess};
|
|
dwRet = WaitForMultipleObjects(2, handles, FALSE, gDllhostInitializationTimeout);
|
|
}
|
|
else
|
|
{
|
|
dwRet = WaitForSingleObject(hInitEvent, gDllhostInitializationTimeout);
|
|
}
|
|
|
|
if (dwRet == WAIT_TIMEOUT)
|
|
{
|
|
hr = CO_E_SERVER_INIT_TIMEOUT;
|
|
}
|
|
else if (dwRet == WAIT_OBJECT_0)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else if (dwRet == WAIT_OBJECT_0+1)
|
|
{
|
|
hr = CO_E_SERVER_STOPPING;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
CloseHandle(hInitEvent);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::GetServerListWithLock
|
|
//
|
|
// Returns a pointer to this entry's server list. Takes shared lock before
|
|
// returning. Caller is expected to call ReleaseSharedListLock to release
|
|
// the lock
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CServerList* CServerTableEntry::GetServerListWithSharedLock()
|
|
{
|
|
ServerLock()->LockShared();
|
|
return &_ServerList;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// CServerTableEntry::ReleaseSharedListLock
|
|
//
|
|
// Releases a shared lock on this entry's list lock.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
void CServerTableEntry::ReleaseSharedListLock()
|
|
{
|
|
ServerLock()->UnlockShared();
|
|
}
|
|
|
|
|
|
//
|
|
// CServerTableEntry::SuspendClass
|
|
//
|
|
// Turns on the suspended flag for this entry.
|
|
//
|
|
void CServerTableEntry::SuspendClass()
|
|
{
|
|
ASSERT(!_bSuspendedClsid &&
|
|
!_bSuspendedApplication &&
|
|
_EntryType == ENTRY_TYPE_CLASS);
|
|
|
|
_bSuspendedClsid = TRUE;
|
|
|
|
SetSuspendOnAllServers(TRUE);
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::UnsuspendClass
|
|
//
|
|
// Turns off the suspended flag for this entry.
|
|
//
|
|
void CServerTableEntry::UnsuspendClass()
|
|
{
|
|
ASSERT(_bSuspendedClsid &&
|
|
!_bSuspendedApplication &&
|
|
_EntryType == ENTRY_TYPE_CLASS);
|
|
|
|
_bSuspendedClsid = FALSE;
|
|
|
|
SetSuspendOnAllServers(FALSE);
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::RetireClass
|
|
//
|
|
// Retires all currently registered servers for
|
|
// this clsid.
|
|
//
|
|
void CServerTableEntry::RetireClass()
|
|
{
|
|
ASSERT(_EntryType == ENTRY_TYPE_CLASS);
|
|
|
|
RetireAllServers();
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::SuspendApplication
|
|
//
|
|
// Turns on the suspended flag for this entry.
|
|
//
|
|
void CServerTableEntry::SuspendApplication()
|
|
{
|
|
ASSERT(!_bSuspendedClsid &&
|
|
!_bSuspendedApplication &&
|
|
_EntryType == ENTRY_TYPE_PROCESS);
|
|
|
|
_bSuspendedClsid = TRUE;
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::UnsuspendApplication
|
|
//
|
|
// Turns on the suspended flag for this entry.
|
|
//
|
|
void CServerTableEntry::UnsuspendApplication()
|
|
{
|
|
ASSERT(!_bSuspendedClsid &&
|
|
_bSuspendedApplication &&
|
|
_EntryType == ENTRY_TYPE_PROCESS);
|
|
|
|
_bSuspendedClsid = FALSE;
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::RetireApplication
|
|
//
|
|
// Marks as retired all servers registered with
|
|
// this entry.
|
|
//
|
|
void CServerTableEntry::RetireApplication()
|
|
{
|
|
ASSERT(_EntryType == ENTRY_TYPE_PROCESS);
|
|
|
|
RetireAllServers();
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::IsSuspended
|
|
//
|
|
// Returns TRUE if servers of this type are
|
|
// currently suspended, FALSE otherwise.
|
|
//
|
|
BOOL CServerTableEntry::IsSuspended()
|
|
{
|
|
ASSERT(_EntryType == ENTRY_TYPE_CLASS ||
|
|
_EntryType == ENTRY_TYPE_PROCESS);
|
|
|
|
if (_EntryType == ENTRY_TYPE_CLASS)
|
|
return _bSuspendedClsid;
|
|
else
|
|
return _bSuspendedApplication;
|
|
}
|
|
|
|
|
|
//
|
|
// CServerTableEntry::SetSuspendOnAllServers
|
|
//
|
|
// Sets the suspended bit on all currently registered servers.
|
|
//
|
|
void CServerTableEntry::SetSuspendOnAllServers(BOOL bSuspended)
|
|
{
|
|
CServerListEntry * pEntry;
|
|
|
|
ServerLock()->LockShared();
|
|
|
|
for (pEntry = (CServerListEntry *) _ServerList.First();
|
|
pEntry;
|
|
pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
if (bSuspended)
|
|
pEntry->Suspend();
|
|
else
|
|
pEntry->Unsuspend();
|
|
}
|
|
|
|
ServerLock()->UnlockShared();
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::RetireAllServers
|
|
//
|
|
// Marks as retired all currently registered servers.
|
|
//
|
|
void CServerTableEntry::RetireAllServers()
|
|
{
|
|
CServerListEntry * pEntry;
|
|
|
|
ServerLock()->LockShared();
|
|
|
|
for (pEntry = (CServerListEntry *) _ServerList.First();
|
|
pEntry;
|
|
pEntry = (CServerListEntry *) pEntry->Next() )
|
|
{
|
|
pEntry->Retire();
|
|
}
|
|
|
|
ServerLock()->UnlockShared();
|
|
}
|
|
|
|
//
|
|
// CServerTableEntry::SetSuspendedFlagOnNewServer
|
|
//
|
|
// Helper function for when a new class factory registration/app
|
|
// comes along. If we are currently suspended, then we need to
|
|
// pass that state on to the new server. If we're not suspended,
|
|
// then there's nothing to do.
|
|
//
|
|
void CServerTableEntry::SetSuspendedFlagOnNewServer(CProcess* pprocess)
|
|
{
|
|
if ( (_EntryType == ENTRY_TYPE_CLASS) && _bSuspendedClsid)
|
|
{
|
|
pprocess->Suspend();
|
|
}
|
|
else if ( (_EntryType == ENTRY_TYPE_PROCESS) && _bSuspendedApplication)
|
|
{
|
|
pprocess->Suspend();
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// SCMRemoveRegistration Version 1: for class entries representing traditional
|
|
// local servers including custom surrogate servers.
|
|
//
|
|
// Called from CProcess::RevokeClassRegs() in the resolver.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
SCMRemoveRegistration(
|
|
CProcess * pProcess,
|
|
GUID & Guid,
|
|
DWORD Reg
|
|
)
|
|
{
|
|
CServerTableEntry * pClassTableEntry = NULL;
|
|
|
|
pClassTableEntry = gpClassTable->Lookup( Guid );
|
|
|
|
if ( pClassTableEntry )
|
|
{
|
|
pClassTableEntry->RevokeServer( pProcess, Reg );
|
|
pClassTableEntry->Release();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// SCMRemoveRegistration Version 2: for process entries representing
|
|
// new unified surrogate servers.
|
|
//
|
|
// Called from CProcess::RevokeClassRegs() in the resolver.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void
|
|
SCMRemoveRegistration(
|
|
ScmProcessReg * pScmProcessReg
|
|
)
|
|
{
|
|
CServerTableEntry * pProcessTableEntry = NULL;
|
|
|
|
pProcessTableEntry = gpProcessTable->Lookup( pScmProcessReg->ProcessGUID );
|
|
|
|
if ( pProcessTableEntry )
|
|
{
|
|
pProcessTableEntry->RevokeServer( pScmProcessReg );
|
|
pProcessTableEntry->Release();
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
SCMProcessCleanup(
|
|
const CProcess *pProcess
|
|
)
|
|
{
|
|
#ifndef _CHICAGO_
|
|
CSurrogateListEntry *pSurrogateEntry = gpSurrogateList->Lookup(pProcess);
|
|
if (pSurrogateEntry)
|
|
{
|
|
gpSurrogateList->Remove(pSurrogateEntry);
|
|
pSurrogateEntry->Release();
|
|
}
|
|
#endif
|
|
}
|
|
|