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; }