able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/dcomss/olescm/activate.cxx

1007 lines
32 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// activate.cxx
//
// Main dcom activation service routines.
//
// History: VinayKr Created
// 06-Nov-98 TarunA Changed remote/local activation logic
//
//--------------------------------------------------------------------------
#include "act.hxx"
HRESULT GetProcessInfoFromActProps(IActivationPropertiesIn* pActPropsIn, DWORD* ppid, DWORD* pdwProcessReqType);
LPWSTR GetOrigSrvrName( PACTIVATION_PARAMS pActParams );
// Global counter
LONG gThreadToken = 0;
//-------------------------------------------------------------------------
//
// Activation
//
// Main entry point for both local and remote activations.
//
//-------------------------------------------------------------------------
HRESULT
Activation(
IN OUT PACTIVATION_PARAMS pActParams
)
{
CServerTableEntry* pServerTableEntry = NULL;
CClsidData* pClsidData = NULL;
CServerListEntry* pServerListEntry;
HANDLE hLaunchMutex = 0;
HRESULT hr;
RPC_STATUS Status;
BOOL bStatus;
BOOL bFirstTime = TRUE;
CToken* pTkn;
// NT #294385
// If REMOTE_SERVER is set, and LOCAL_SERVER is not,
// and we have a server name, and the server name is us,
// then we need to turn the LOCAL_SERVER flag on
if ( (CLSCTX_REMOTE_SERVER == (pActParams->ClsContext & ( CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER ))) &&
pActParams->pwszServer != NULL &&
gpMachineName->Compare (pActParams->pwszServer) )
{
pActParams->ClsContext |= CLSCTX_LOCAL_SERVER;
}
#ifdef SECURITY_DBG
{
WCHAR dbgwszUser[MAX_PATH];
if ( pActParams->pToken != NULL )
{
pActParams->pToken->Impersonate();
ULONG cchSize = MAX_PATH;
GetUserName( dbgwszUser, &cchSize );
pActParams->pToken->Revert();
}
else
{
lstrcpyW( dbgwszUser, L"Anonymous" );
}
}
#endif
if ( pActParams->pwszServer )
{
//
// Some apps may unnecessarily put slashes before their
// server names. We'll allow this and strip them off.
//
if ( pActParams->pwszServer[0] == L'\\' &&
pActParams->pwszServer[1] == L'\\' )
pActParams->pwszServer += 2;
if ( 0 == *pActParams->pwszServer )
{
hr = CO_E_BAD_SERVER_NAME;
goto ActivationDone;
}
if ( ! gpMachineName->Compare( pActParams->pwszServer ) )
{
//
// When a client specifies a remote server name we go straight to the
// source, there is no need to check local configuration information.
//
// The CLSCTX_REMOTE_SERVER bit does not need to be specified by the
// client, it is implied.
//
//
// the remote activation call will null out the pointer in the ActivationPropertiesIn
// object which caused the memory that pActParams->pwszServer is pointing to to be
// freed. We need this name later on to pass to the oxid resoluton phase, so
// we copy it to some memory on the stack
//
WCHAR *pszTemp = (WCHAR *)_alloca( ( lstrlenW(pActParams->pwszServer) + 1 ) * sizeof(WCHAR) );
lstrcpyW(pszTemp, pActParams->pwszServer);
hr = RemoteActivationCall( pActParams, pActParams->pwszServer );
pActParams->pwszServer = pszTemp;
goto ActivationDone;
}
}
//
// First search for a running object.
//
if ( pActParams->pwszPath )
{
//
// This call returns TRUE if we found a ROT object and are now done.
// When handling a remote activation it's possible we'll find a ROT
// object, but we still need to continue in this case to get a remote
// marshalled interface.
//
if ( LookupObjectInROT( pActParams, &hr ) )
goto ActivationDone;
}
//
// Try to get a CClsidData using the supplied pComClassInfo
//
pTkn = pActParams->RemoteActivation ? NULL : pActParams->pToken;
hr = LookupClsidData( pActParams->Clsid,
pActParams->pComClassInfo,
pTkn,
LOAD_NORMAL,
&pClsidData );
if (hr == REGDB_E_CLASSNOTREG)
{
ASSERT(!pClsidData);
// No registration info for this clsid. If the client is interested
// in a local server activation, we still need to check the class
// table in case of unsolicited registrations. For COM+ components
// we should never get here.
if(pActParams->ClsContext & CLSCTX_LOCAL_SERVER)
{
pServerTableEntry = gpClassTable->Lookup(pActParams->Clsid);
if (pServerTableEntry)
{
// Somebody on the machine registered a classfac for this
// clsid; give it a shot:
bStatus = pServerTableEntry->CallRunningServer( pActParams,
0,
0,
NULL,
&hr);
if (bStatus)
goto ActivationDone;
}
}
//
// As a last resort we always try an atstorage activation.
//
ActivateAtStorage( pActParams, NULL, &hr );
goto ActivationDone;
}
else if (FAILED(hr))
goto ActivationDone;
Win4Assert(pClsidData && "Registration lookup succeeded but returned nothing");
// Look up an appropriate table entry if the client is interested in a
// local activation
if(pActParams->ClsContext & CLSCTX_LOCAL_SERVER)
{
if (pClsidData->DllHostOrComPlusProcess())
{
GUID* pAppidGuid = pClsidData->AppidGuid();
ASSERT(pAppidGuid);
pServerTableEntry = gpProcessTable->Lookup(*pAppidGuid);
}
else
pServerTableEntry = gpClassTable->Lookup( pActParams->Clsid );
}
if ( !pServerTableEntry )
{
// At this point we have the class data but no running servers. If the
// client wants remote activation only then go straight to do a remote activation
// NOTE We '&' with flags CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER to
// filter out any other bits like CLSCTX_INPROC etc
if( (pActParams->ClsContext & (CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER)) == CLSCTX_REMOTE_SERVER)
{
// This call returns TRUE if a remote ActivateAtStorage call was
// made, whether successful or not.
if ( ActivateAtStorage( pActParams, pClsidData, &hr ) )
goto ActivationDone;
else
goto ActivationDoneLocal;
}
// Figure out which table to create the table entry in
if (pClsidData->DllHostOrComPlusProcess())
{
GUID* pAppidGuid = pClsidData->AppidGuid();
ASSERT(pAppidGuid);
pServerTableEntry = gpProcessTable->Create(*pAppidGuid);
}
else
pServerTableEntry = gpClassTable->Create(pActParams->Clsid);
if (!pServerTableEntry)
{
hr = E_OUTOFMEMORY;
goto ActivationDone;
}
}
Win4Assert(pServerTableEntry);
hr = GetProcessInfoFromActProps(pActParams->pActPropsIn, &(pActParams->dwPID), &(pActParams->dwProcessReqType));
if (FAILED(hr))
goto ActivationDone;
for (;;)
{
//
// Now check for a running server for the CLSID
// NOTE: The fact that we reached here implies that the client wants at least a
// local activation
//
CairoleDebugOut((DEB_SCM, "Calling ServerTableEntry at 0x%p\n", pServerTableEntry));
// We reach here only when we are interested in at least a local activation
Win4Assert(pActParams->ClsContext & CLSCTX_LOCAL_SERVER);
// We always try to use an existing running server, unless a custom
// activator has told us specifically to create a new server.
if (pActParams->dwProcessReqType != PRT_CREATE_NEW)
{
bStatus = pServerTableEntry->CallRunningServer( pActParams,
0,
0,
pClsidData,
&hr);
if ( bStatus )
goto ActivationDone;
else
{
if (pActParams->dwProcessReqType == PRT_USE_THIS_ONLY)
{
// A custom activator specified a specific server which was not
// found. No need to continue further.
hr = E_UNEXPECTED; // REVIEW for better error code!
goto ActivationDone;
}
else if(pActParams->dwProcessReqType == PRT_USE_THIS)
{
// A custom activator hinted at a specific process, which was not
// found. Eg, the process in question was killed, died, etc. Although
// this should not happen much in the normal case, it would be nice if
// we could somehow save the client from getting an error. So what we
// do is re-try the activation using any compatible server. If it works
// great, if not then we're done (we won't start a new server).
// note we're only resetting the pertinent flags in the actparams struct,
// not the actprops object, but everybody downstream from here only looks
// at the actparams so this is okay.
pActParams->dwProcessReqType = PRT_IGNORE;
pActParams->dwPID = 0;
bStatus = pServerTableEntry->CallRunningServer( pActParams,
0,
0,
pClsidData,
&hr);
goto ActivationDone;
}
// else { keep going }
}
}
if (bFirstTime)
{
bFirstTime = FALSE;
//
// Try to do at-storage first
//
if (ActivateAtStorage(pActParams, pClsidData, &hr))
goto ActivationDone;
// Try a remote activation if
// (1a) Class is configured to be activated remotely
// AND
// (1b) Client will accept a remote activation
// OR
// (2)SERVERTYPE_NONE
if( (((pClsidData->GetAcceptableContext() & (CLSCTX_REMOTE_SERVER | CLSCTX_LOCAL_SERVER)) == CLSCTX_REMOTE_SERVER)
&&
(pActParams->ClsContext & CLSCTX_REMOTE_SERVER))
||
(pClsidData->ServerType() == SERVERTYPE_NONE) )
goto ActivationDoneLocal;
}
if ( ! hLaunchMutex )
{
hLaunchMutex = pClsidData->ServerLaunchMutex();
if (!hLaunchMutex)
{
hr = E_UNEXPECTED;
goto ActivationDone;
}
}
else
WaitForSingleObject( hLaunchMutex, INFINITE );
// At this point we now hold the launch mutex
// If we've been told explicitly to launch a new server process, then
// there's no reason to check for one already running.
if (pActParams->dwProcessReqType != PRT_CREATE_NEW)
{
// If server exists, release launch mutex and try
// to call server
BOOL fExists;
hr = pServerTableEntry->ServerExists(pActParams, &fExists);
if (hr != S_OK)
{
ReleaseMutex( hLaunchMutex );
goto ActivationDone;
}
if (fExists)
{
ReleaseMutex( hLaunchMutex );
continue;
}
}
ASSERT(pActParams->dwProcessReqType == PRT_IGNORE ||
pActParams->dwProcessReqType == PRT_CREATE_NEW);
RpcTryExcept
{
LONG lLaunchThreadToken;
//
// This returns when the server has registered the requested CLSID or
// we give up.
//
CairoleDebugOut((DEB_SCM, "Starting ServerTableEntry at 0x%p\n", pServerTableEntry));
// Grab a non-zero token for the launch that we will
// use to associate the server with on the call
do {
lLaunchThreadToken = InterlockedIncrement(&gThreadToken);
}
while (lLaunchThreadToken == 0);
// Use the token to launch
// Note that StartServerAndWait could reset the token
// to zero in some cases.
hr = pServerTableEntry->StartServerAndWait( pActParams,
pClsidData,
lLaunchThreadToken);
// Now call the server with the LaunchMutex held but
// with the threadtoken to guarantee first access to
// the class in the server we launched. This takes
// care of SINGLEUSE as well as transient error cases.
if (SUCCEEDED(hr))
{
// NOTE: if the server we just launched was an "extra" one (ie, on
// behalf of some custom activator), it's not guaranteed that this
// activation will use the just-launched server. It may get an old one.
bStatus = pServerTableEntry->CallRunningServer(pActParams,
0,
lLaunchThreadToken,
pClsidData,
&hr);
if (!bStatus)
hr = CO_E_SERVER_EXEC_FAILURE;
}
}
RpcExcept(TRUE)
{
Win4Assert(NULL && "Unexpected exception thrown");
Status = RpcExceptionCode();
hr = HRESULT_FROM_WIN32(Status);
}
RpcEndExcept
ReleaseMutex( hLaunchMutex );
break;
}// end for(;;)
goto ActivationDone;
ActivationDoneLocal:
hr = REGDB_E_CLASSNOTREG;
//
// Server name will only be non-null if its our machine name.
//
if ( !pActParams->pwszServer &&
pClsidData->RemoteServerNames() )
{
//
// the remote activation call will null out the pointer in the ActivationPropertiesIn
// object which caused the memory that pActParams->pwszServer is pointing to to be
// freed. We need this name later on to pass to the oxid resoluton phase, so
// we copy it to some memory on the stack
//
// We don't care here since pActParams->pwszServer==NULL if we are here.
if (!ActivateRemote( pActParams, pClsidData, &hr ))
{
hr = (CLSCTX_REMOTE_SERVER == pActParams->ClsContext) ?
CO_E_CANT_REMOTE : REGDB_E_CLASSNOTREG;
}
}
ActivationDone:
if (hLaunchMutex)
CloseHandle( hLaunchMutex );
// Registry data is not cached in any way.
if ( pClsidData )
delete pClsidData;
if ( pServerTableEntry )
pServerTableEntry->Release();
// Don't need to resolve if we're return an inproc server.
if ( (S_OK == hr) && ! *pActParams->ppwszDllServer )
hr = ResolveORInfo( pActParams);
return hr;
}
//-------------------------------------------------------------------------
//
// ResolveORInfo
//
// On the server side of a remote activation, gets the OXID in the
// marshalled interface pointer.
//
// For a client side activation (local or remote), calls revolve OXID.
//
//-------------------------------------------------------------------------
HRESULT
ResolveORInfo(
IN OUT PACTIVATION_PARAMS pActParams
)
{
MInterfacePointer * pIFD;
OBJREF * pObjRef;
STDOBJREF * pStdObjRef;
DUALSTRINGARRAY * pORBindings;
DWORD DataSize;
RPC_STATUS sc;
DWORD n;
BOOL ActivatedRemote = pActParams->activatedRemote;
// Don't resolve if we are servicing a remote activation and
// we also did a remote activation(i.e LB router)
if (pActParams->RemoteActivation && ActivatedRemote)
return S_OK;
//
// This routine probes the interface data returned from the server's
// OLE during a successfull activation, but we're still going to
// protect ourself from bogus data.
//
if (pActParams->pActPropsOut)
{
HRESULT hr;
pActParams->pIIDs = 0;
pActParams->pResults = 0;
pActParams->ppIFD = 0;
hr = pActParams->pActPropsOut->GetMarshalledResults(&pActParams->Interfaces,
&pActParams->pIIDs,
&pActParams->pResults,
&pActParams->ppIFD);
if (hr != S_OK)
return hr;
}
pIFD = 0;
for ( n = 0; n < pActParams->Interfaces; n++ )
{
pIFD = pActParams->ppIFD[n];
if ( pIFD )
break;
}
Win4Assert( pIFD );
if ( pIFD->ulCntData < 2*sizeof(ULONG) )
{
Win4Assert( !"Bad interface data returned from server" );
return S_OK;
}
pObjRef = (OBJREF *)pIFD->abData;
if ( (pObjRef->signature != OBJREF_SIGNATURE) ||
(pObjRef->flags & ~(OBJREF_STANDARD | OBJREF_HANDLER |
OBJREF_CUSTOM | OBJREF_EXTENDED)) ||
(pObjRef->flags == 0) )
{
Win4Assert( !"Bad interface data returned from server" );
return S_OK;
}
// No OR info sent back for custom marshalled interfaces.
if ( pObjRef->flags == OBJREF_CUSTOM )
return S_OK;
DataSize = 2*sizeof(ULONG) + sizeof(GUID);
pStdObjRef = (STDOBJREF *)(pIFD->abData + DataSize);
DataSize += sizeof(STDOBJREF);
if ( pObjRef->flags == OBJREF_HANDLER )
DataSize += sizeof(CLSID);
else if( pObjRef->flags == OBJREF_EXTENDED)
DataSize += sizeof(DWORD);
pORBindings = (DUALSTRINGARRAY *)(pIFD->abData + DataSize);
DataSize += 2 * sizeof(USHORT);
if ( pIFD->ulCntData < DataSize )
{
Win4Assert( !"Bad interface data returned from server" );
return S_OK;
}
// If we activated the server on this machine, we need the OXID of the server.
if ( ! ActivatedRemote )
*pActParams->pOxidServer = *((OXID UNALIGNED *)&pStdObjRef->oxid);
//
// If we're servicing a remote activation, all we need is the server's OXID.
// The client will call ResolveClientOXID from its ResolveORInfo.
//
if ( pActParams->RemoteActivation )
return S_OK;
DataSize += pORBindings->wNumEntries * sizeof(USHORT);
if ( (pIFD->ulCntData < DataSize) ||
(pORBindings->wNumEntries != 0 &&
(pORBindings->wSecurityOffset >= pORBindings->wNumEntries)) )
{
Win4Assert( !"Bad interface data returned from server" );
return S_OK;
}
//
// If empty OR bindings were supplied then the server and client are
// both local to this machine, so use the local OR bindings.
//
if (pORBindings->wNumEntries == 0)
{
sc = CopyMyOrBindings(pActParams->ppServerORBindings, NULL);
if (sc != RPC_S_OK)
return HRESULT_FROM_WIN32(sc);
}
else
{
#if 0 // #ifdef _CHICAGO_
if (pORBindings->wNumEntries == 0)
pORBindings = gpLocalDSA;
#endif // _CHICAGO_
//
// This was a local activation so use our string bindings for the OR
// binding string.
//
*pActParams->ppServerORBindings = (DUALSTRINGARRAY *)
MIDL_user_allocate( sizeof(DUALSTRINGARRAY) +
pORBindings->wNumEntries*sizeof(USHORT) );
if ( ! *pActParams->ppServerORBindings )
return E_OUTOFMEMORY;
dsaCopy( *pActParams->ppServerORBindings, pORBindings );
}
//
// If we did a remote activation then we already have the server's OXID and
// OR string bindings from the RemoteActivation call and pieces of the OXID
// info have been filled in.
//
// Could we optimize this at all for the local case?
#if 0 // #ifdef _CHICAGO_
sc = ScmResolveClientOXID(
*pActParams->pOxidServer,
*pActParams->ppServerORBindings,
pActParams->Apartment,
pActParams->ProtseqId,
*pActParams->pOxidInfo,
*pActParams->pLocalMidOfRemote
);
#else
USHORT usAuthnSvc;
sc = ResolveClientOXID( pActParams->hRpc,
(PVOID)pActParams->pProcess,
pActParams->pOxidServer,
*pActParams->ppServerORBindings,
pActParams->Apartment,
pActParams->ProtseqId,
pActParams->pwszServer,
pActParams->pOxidInfo,
pActParams->pLocalMidOfRemote,
pActParams->UnsecureActivation,
pActParams->AuthnSvc,
&pActParams->IsLocalOxid,
&usAuthnSvc);
#endif
return HRESULT_FROM_WIN32(sc);
}
//-------------------------------------------------------------------------
//
// ActivateAtStorage
//
// If the given CLSID is marked with ActivateAtStorage, do a remote
// activation to the machine where the path points.
//
// Returns TRUE if a remote activation was tried or a wierd error was
// encoutered. Returns FALSE if the CLSID is not marked with
// ActivateAtStorage or the file path is determined to be local.
//
//-------------------------------------------------------------------------
BOOL
ActivateAtStorage(
IN OUT ACTIVATION_PARAMS * pActParams,
IN CClsidData * pClsidData,
OUT HRESULT * phr
)
{
//
// See if we need to do a remote ActivateAtStorage activation. If
// a server name is given, then we either made a remote activation
// already or the server name is for the local machine in which case
// ActivateAtStorage is ignored.
LPWSTR pwszOrigSrvrName=NULL;
pwszOrigSrvrName = GetOrigSrvrName(pActParams);
if ( pActParams->RemoteActivation ||
pActParams->pwszServer ||
pwszOrigSrvrName ||
!pActParams->pwszPath )
return FALSE;
// Note that if we have no information at all for a CLSID, we try a
// atstorage activation. Part of initial dcom spec.
//
if ( pClsidData && ! pClsidData->ActivateAtStorage() )
return FALSE;
HRESULT hr;
WCHAR wszMachineName[MAX_COMPUTERNAME_LENGTH+1];
//
#ifdef DFSACTIVATION
//
// This is for DFS support. If the file hasn't been opened yet, we must
// open it before trying to resolve the DFS pathname in GetMachineName.
// This is just how DFS works. FindFirstFile results in the fewest number
// of network packets.
//
if ( ! pActParams->FileWasOpened )
{
HANDLE hFile;
WIN32_FIND_DATA Data;
if (pActParams->pToken != NULL)
pActParams->pToken->Impersonate();
hFile = FindFirstFile( pActParams->pwszPath, &Data );
if ( hFile != INVALID_HANDLE_VALUE )
(void) FindClose( hFile );
if (pActParams->pToken != NULL)
pActParams->pToken->Revert();
if ( INVALID_HANDLE_VALUE == hFile )
{
*phr = CO_E_BAD_PATH;
return TRUE;
}
}
#endif
hr = GetMachineName(
pActParams->pwszPath,
wszMachineName
#ifdef DFSACTIVATION
,TRUE
#endif
);
if ( hr == S_FALSE )
{
// We couldn't get the machine name, path must be local.
return FALSE;
}
else if ( hr != S_OK )
{
// We got an error while trying to find the UNC machine name.
*phr = hr;
return TRUE;
}
if ( gpMachineName->Compare( wszMachineName ) )
return FALSE;
*phr = RemoteActivationCall( pActParams, wszMachineName );
return TRUE;
}
//-------------------------------------------------------------------------
//
// ActivateRemote
//
// Does a remote activation based off of the RemoteServerName registry key
// for the given CLSID.
//
// Returns TRUE if a remote activation was tried, FALSE if not.
//
//-------------------------------------------------------------------------
BOOL
ActivateRemote(
IN OUT ACTIVATION_PARAMS * pActParams,
IN CClsidData * pClsidData,
OUT HRESULT * phr
)
{
WCHAR * pwszServerName;
BOOL bBadServerName;
BOOL bMyServerName;
*phr = S_OK;
//
// The CClsidData class puts the remote server name(s) into a REG_MULTI_SZ
// format.
//
pwszServerName = pClsidData->RemoteServerNames();
// jsimmons 3/11/00 prefix bug fix. We would crash below if RemoteServerNames
// returned NULL (which is possible). The only caller of this function checks
// that before calling us, though. However, it doesn't hurt to make sure.
if (!pwszServerName)
{
ASSERT(0);
*phr = E_UNEXPECTED;
return FALSE;
}
bBadServerName = TRUE;
bMyServerName = TRUE;
for ( ; *pwszServerName; pwszServerName += lstrlenW(pwszServerName) + 1 )
{
if ( pwszServerName[0] == L'\\' && pwszServerName[1] == L'\\' )
pwszServerName += 2;
while ( *pwszServerName &&
(*pwszServerName == L' ' || *pwszServerName == L'\t') )
pwszServerName++;
if ( pwszServerName[0] == L'\0' )
continue;
bBadServerName = FALSE;
if ( gpMachineName->Compare( pwszServerName ) )
continue;
bMyServerName = FALSE;
*phr = RemoteActivationCall( pActParams, pwszServerName );
if ( S_OK == *phr )
break;
}
if ( bBadServerName || bMyServerName )
return FALSE;
return TRUE;
}
//-------------------------------------------------------------------------
//
// CheckLocalCall
//
// Verifies that the handle for our current call is for a local transport.
// Raises an exception if it's not.
//
//-------------------------------------------------------------------------
void
CheckLocalCall(
IN handle_t hRpc
)
{
#if 1 // #ifndef _CHICAGO_
UINT Type;
if ( (I_RpcBindingInqTransportType( hRpc, &Type) != RPC_S_OK) ||
((Type != TRANSPORT_TYPE_LPC) && (Type != TRANSPORT_TYPE_WMSG)) )
RpcRaiseException( ERROR_ACCESS_DENIED );
#endif
//
// We probably want to enable this on Chicago now too.
//
}
//-------------------------------------------------------------------------
//
// LookupObjectInROT
//
// Looks for an object (file path in this activation) in the Running Object
// Table.
//
// Returns TRUE if we found the object in the ROT and can pass its
// marshalled interface pointer directly back to the client.
//
//-------------------------------------------------------------------------
BOOL
LookupObjectInROT(
IN PACTIVATION_PARAMS pActParams,
OUT HRESULT * phr )
{
SCMREGKEY Key;
MNKEQBUF * pMnkEqBuf;
BYTE Buffer[sizeof(DWORD)+ROT_COMPARE_MAX];
pMnkEqBuf = (MNKEQBUF *) Buffer;
*phr = CreateFileMonikerComparisonBuffer(
pActParams->pwszPath,
&pMnkEqBuf->abEqData[0],
ROT_COMPARE_MAX,
&pMnkEqBuf->cdwSize );
if ( *phr != S_OK )
return FALSE;
*phr = gpscmrot->GetObject(
pActParams->pToken,
pActParams->pProcess ? pActParams->pProcess->WinstaDesktop() : NULL,
0,
pMnkEqBuf,
&Key,
(InterfaceData **)&pActParams->pIFDROT );
if ( *phr != S_OK )
return FALSE;
//
// If our activation call is from a local client and for a single
// interface then we can return success. Otherwise we return failure
// because we must call the server either to get more interface
// pointers or because we are servicing a remote activation and must get
// a normal marshalled interface pointer rather than the table marshalled
// interface pointer sitting in the ROT.
//
if ( ! pActParams->RemoteActivation && (1 == pActParams->Interfaces) )
{
// Return the marshaled interface from the ROT to the caller.
pActParams->ppIFD = (MInterfacePointer **)
MIDL_user_allocate(sizeof(MInterfacePointer *));
pActParams->pResults = (HRESULT*) MIDL_user_allocate(sizeof(HRESULT));
if ((pActParams->ppIFD==NULL) || (pActParams->pResults==NULL))
{
MIDL_user_free(pActParams->ppIFD);
MIDL_user_free(pActParams->pResults);
*phr = E_OUTOFMEMORY;
return FALSE;
}
*pActParams->ppIFD = pActParams->pIFDROT;
pActParams->pResults[0] = S_OK;
// So we remember not to clean up the buffer
pActParams->pIFDROT = NULL;
// Let caller know that we got this from the ROT so
// if it doesn't work they should try again.
pActParams->FoundInROT = TRUE;
*pActParams->pFoundInROT = TRUE;
return TRUE;
}
//
// REVIEW REVIEW. Can we return success if the ROT object was marshalled
// strong? Do we really have to call the server if the object was
// marshalled weak? Is the resulting race condition any worse then for a
// normal activation?
//
//
// We can't use a tabled marshalled interface pointer to send back to a
// remote client, so we return failure here, but keep the ROT interface
// data in pIFDROT.
//
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Get the COSERVERINFO supplied by the client. We'll use this to decide
// whether we want to do remote ActivateAtStorage.
//
//+---------------------------------------------------------------------------
LPWSTR GetOrigSrvrName(
PACTIVATION_PARAMS pActParams
)
{
LPWSTR pwszOrigSrvrName = NULL;
if (pActParams->pActPropsIn)
{
SecurityInfo* pLegacyInfo = pActParams->pActPropsIn->GetSecurityInfo();
if (pLegacyInfo)
{
COSERVERINFO* pServerInfo = NULL;
pLegacyInfo->GetCOSERVERINFO(&pServerInfo);
if (pServerInfo)
{
pwszOrigSrvrName = pServerInfo->pwszName;
}
}
}
return pwszOrigSrvrName;
}
//
// Helper function. ppid and pdwProcessReqType may be NULL if caller does not care about them.
//
HRESULT GetProcessInfoFromActProps(IActivationPropertiesIn* pActPropsIn, DWORD* ppid, DWORD* pdwProcessReqType)
{
HRESULT hr = E_INVALIDARG;
ASSERT(pActPropsIn);
if (pActPropsIn != NULL)
{
IServerLocationInfo *pSLInfo = NULL;
hr = pActPropsIn->QueryInterface(IID_IServerLocationInfo, (void**) &pSLInfo);
ASSERT(SUCCEEDED(hr) && pSLInfo);
if (SUCCEEDED(hr) && pSLInfo != NULL)
{
DWORD dwPRT;
DWORD dwPid;
hr = pSLInfo->GetProcess(&dwPid, &dwPRT);
ASSERT(SUCCEEDED(hr));
ASSERT(dwPRT == PRT_IGNORE ||
dwPRT == PRT_CREATE_NEW ||
dwPRT == PRT_USE_THIS ||
dwPRT == PRT_USE_THIS_ONLY);
if (SUCCEEDED(hr))
{
if (ppid)
*ppid = dwPid;
if (pdwProcessReqType)
*pdwProcessReqType = dwPRT;
}
pSLInfo->Release();
pSLInfo = NULL;
}
}
return hr;
}
Reference in a new issue Copy permalink