HRESULT CorHost::UnloadDomain(IUnknown *pUnkDomain)
{
HRESULT hr = S_OK;
if(!pUnkDomain) return E_POINTER;
BEGINCANNOTTHROWCOMPLUSEXCEPTION();
Thread* pThread = GetThread();
if (!pThread)
IfFailGo(E_UNEXPECTED);
IfFailGo(QuickCOMStartup());
BEGIN_ENSURE_COOPERATIVE_GC();
COMPLUS_TRY {
// unload doesn't need to switch to the domain to be unloaded
OBJECTREF pRef = NULL;
GCPROTECT_BEGIN(pRef);
pRef = GetObjectRefFromComIP(pUnkDomain);
MethodDesc* pMD = g_Mscorlib.GetMethod(METHOD__APP_DOMAIN__UNLOAD);
ARG_SLOT arg = ObjToArgSlot((OBJECTREF) pRef);
pMD->Call(&arg, METHOD__APP_DOMAIN__UNLOAD);
GCPROTECT_END();
} COMPLUS_CATCH {
hr = SecurityHelper::MapToHR(GETTHROWABLE());
} COMPLUS_END_CATCH
END_ENSURE_COOPERATIVE_GC();
ErrExit:
ENDCANNOTTHROWCOMPLUSEXCEPTION();
return hr;
}
VOID ComCallWrapper::InvokeByNameCallback(LPVOID ptr)
{
InvokeByNameArgs* args = (InvokeByNameArgs*)ptr;
INT32 NumByrefArgs = 0;
INT32 *aByrefArgMngVariantIndex = NULL;
INT32 iArg;
struct __gc {
OBJECTREF Target;
STRINGREF MemberName;
PTRARRAYREF ParamArray;
OBJECTREF TmpObj;
OBJECTREF RetVal;
} gc;
ZeroMemory(&gc, sizeof(gc));
GCPROTECT_BEGIN(gc);
gc.MemberName = COMString::NewString(args->MemberName);
gc.ParamArray = (PTRARRAYREF)AllocateObjectArray(args->ArgCount, g_pObjectClass);
//
// Fill in the arguments.
//
for (iArg = 0; iArg < args->ArgCount; iArg++)
{
// Convert the variant.
VARIANT *pSrcOleVariant = &args->ArgList[iArg];
OleVariant::MarshalObjectForOleVariant(pSrcOleVariant, &gc.TmpObj);
gc.ParamArray->SetAt(iArg, gc.TmpObj);
// If the argument is byref then add it to the array of byref arguments.
if (V_VT(pSrcOleVariant) & VT_BYREF)
{
if (aByrefArgMngVariantIndex == NULL) {
aByrefArgMngVariantIndex = (INT32 *)_alloca(sizeof(INT32) * args->ArgCount);
}
aByrefArgMngVariantIndex[NumByrefArgs] = iArg;
NumByrefArgs++;
}
}
gc.Target = ObjectFromHandle(args->pThis->m_hThis);
//
// Invoke using IReflect::InvokeMember
//
EEClass *pClass = gc.Target->GetClass();
// Retrieve the method descriptor that will be called on.
MethodDesc *pMD = GetInvokeMemberMD();
// Prepare the arguments that will be passed to Invoke.
ARG_SLOT Args[] = {
ObjToArgSlot(GetReflectionObject(pClass)), // IReflect
ObjToArgSlot(gc.MemberName), // name
(ARG_SLOT) args->BindingFlags, // invokeAttr
ObjToArgSlot(GetOleAutBinder()),// binder
ObjToArgSlot(gc.Target), // target
ObjToArgSlot(gc.ParamArray), // args
ObjToArgSlot(NULL), // modifiers
ObjToArgSlot(NULL), // culture
ObjToArgSlot(NULL) // namedParameters
};
// Do the actual method invocation.
MetaSig metaSig(pMD->GetSig(),pMD->GetModule());
gc.RetVal = ArgSlotToObj(pMD->Call(Args, &metaSig));
//
// Convert the return value and the byref arguments.
//
// Convert all the ByRef arguments back.
for (iArg = 0; iArg < NumByrefArgs; iArg++)
{
INT32 i = aByrefArgMngVariantIndex[iArg];
gc.TmpObj = gc.ParamArray->GetAt(i);
OleVariant::MarshalOleRefVariantForObject(&gc.TmpObj, &args->ArgList[i]);
}
// Convert the return COM+ object to an OLE variant.
if (args->pRetVal)
OleVariant::MarshalOleVariantForObject(&gc.RetVal, args->pRetVal);
GCPROTECT_END();
}
// Creates a domain in the runtime. The identity array is
// a pointer to an array TYPE containing IIdentity objects defining
// the security identity.
HRESULT CorHost::CreateDomainEx(LPCWSTR pwzFriendlyName,
IUnknown* pSetup, // Optional
IUnknown* pEvidence, // Optional
IUnknown ** pAppDomain)
{
HRESULT hr = S_OK;
if(!pwzFriendlyName) return E_POINTER;
if(pAppDomain == NULL) return E_POINTER;
if(g_RefCount == 0) return E_FAIL;
BEGINCANNOTTHROWCOMPLUSEXCEPTION();
// This will set up a managed thread object if one does not already exist
// for this particular thread.
Thread* pThread = SetupThread();
if (pThread == NULL) {
hr = E_OUTOFMEMORY;
goto Exit;
}
if (!pThread) {
hr = E_UNEXPECTED;
goto Exit;
}
if (FAILED(hr = QuickCOMStartup()))
goto Exit;
BOOL fWasGCEnabled;
fWasGCEnabled = !pThread->PreemptiveGCDisabled();
if (fWasGCEnabled)
pThread->DisablePreemptiveGC();
COMPLUS_TRY {
struct _gc {
STRINGREF pName;
OBJECTREF pSetup;
OBJECTREF pEvidence;
APPDOMAINREF pDomain;
} gc;
ZeroMemory(&gc, sizeof(gc));
GCPROTECT_BEGIN(gc);
gc.pName = COMString::NewString(pwzFriendlyName);
if(pSetup)
gc.pSetup = GetObjectRefFromComIP(pSetup);
if(pEvidence)
gc.pEvidence = GetObjectRefFromComIP(pEvidence);
MethodDesc *pMD = g_Mscorlib.GetMethod(METHOD__APP_DOMAIN__CREATE_DOMAIN);
ARG_SLOT args[3] = {
ObjToArgSlot(gc.pName),
ObjToArgSlot(gc.pEvidence),
ObjToArgSlot(gc.pSetup),
};
gc.pDomain = (APPDOMAINREF) ArgSlotToObj(pMD->Call(args, METHOD__APP_DOMAIN__CREATE_DOMAIN));
IfFailThrow(QuickCOMStartup());
*pAppDomain = GetComIPFromObjectRef((OBJECTREF*) &gc.pDomain);
GCPROTECT_END();
} COMPLUS_CATCH {
hr = SecurityHelper::MapToHR(GETTHROWABLE());
} COMPLUS_END_CATCH
if (fWasGCEnabled)
pThread->EnablePreemptiveGC();
Exit:
ENDCANNOTTHROWCOMPLUSEXCEPTION();
return hr;
}
