HRESULT CordbAppDomain::QueryInterface(REFIID id, void **ppInterface)
{
if (id == IID_ICorDebugAppDomain)
{
*ppInterface = (ICorDebugAppDomain*)this;
}
else if (id == IID_ICorDebugAppDomain2)
{
*ppInterface = (ICorDebugAppDomain2*)this;
}
else if (id == IID_ICorDebugAppDomain3)
{
*ppInterface = (ICorDebugAppDomain3*)this;
}
else if (id == IID_ICorDebugAppDomain4)
{
*ppInterface = (ICorDebugAppDomain4*)this;
}
else if (id == IID_ICorDebugController)
*ppInterface = (ICorDebugController*)(ICorDebugAppDomain*)this;
else if (id == IID_IUnknown)
*ppInterface = (IUnknown*)(ICorDebugAppDomain*)this;
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
ExternalAddRef();
return S_OK;
}
// IDispatch implementation
void CoAuthRenewTokenAsync::ReadyStateChange()
{
ExternalAddRef(); // lock protect your instance
try
{
TRACE1("CoAuthRenewTokenAsync::IXMLDOMDocumentEvents::OnReadyStateChange() readyState: 0x%.8x\n", m_spRequest->readyState);
switch (m_spRequest->readyState)
{
case READYSTATE_COMPLETE: // = 4
{
/*
* das hier uebergebene X,Y,Z this hat KEINERLEI funktionale bedeutung und dient lediglich dazu
* dem progrmierer auf evtl. fehler hinzuweisen.
* Hintergrund:
* es kann NUR EINEN "wirksamen" CRenewTokenAsync geben. Das ist der der als erstes erzeugt wurde.
* NUR der CRenewTokenAsync der Lock aufgerufen hat kann auch UnLock aufrufen!
* mit dem ersten CRenewTokenAsync wird the<Service> (IAuthorize) verriegelt.
* damit folgerequests nicht blockieren und nicht verlorengehen werden sie in einer queue aufbewahrt.
*
* m_spAuthorize kennt den m_spRequest weil er ihn ja initial selbst erstellt hat.
* m_spAuthorize braucht den m_spRequest weil dort das ergebnis des "Renew" ermittelt wird.
* wir (CRenewTokenAsync) brauchen den m_spRequest lediglich um den callback (OnReadyStateChange) zu registrien bzw. zu deregistrieren.
*/
HRESULT hr = m_spAuthorize->raw_UnLockFromRenew();
_ASSERT(SUCCEEDED(hr));
// break reference cycle, Remove sink from xml http request
// CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt)
// m_spRequest->put_onreadystatechange(NULL);
if (SUCCEEDED(hr))
{
ATLTRACE2(atlTraceGeneral, 1, _T(" continue previous workflow\n"));
m_spRenewCallback->Continue();
}
else
{
ATLTRACE2(atlTraceGeneral, 1, _T(" terminate previous workflow\n"));
m_spRenewCallback->Terminate();
}
m_spRenewCallback = NULL;
}
break;
case READYSTATE_UNINITIALIZED: // = 0,
case READYSTATE_LOADING: // = 1,
case READYSTATE_LOADED: // = 2,
case READYSTATE_INTERACTIVE: // = 3,
default: break;
}
}
catch (const _com_error& e)
{
HRESULT hr = e.Error();
}
ExternalRelease(); // unlock instance, may the last one
}
// return addref'd IDispatch part of CCmdTarget object
LPDISPATCH CCmdTarget::GetIDispatch(BOOL bAddRef)
{
ASSERT_VALID(this);
ASSERT(m_xDispatch.m_vtbl != 0); // forgot to call EnableAutomation?
// AddRef the object if requested
if (bAddRef)
ExternalAddRef();
// return pointer to IDispatch implementation
return (LPDISPATCH)GetInterface(&IID_IDispatch);
}
//=--------------------------------------------------------------------------=
// CStandardEnum::InternalQueryInterface
//=--------------------------------------------------------------------------=
// we support our internal iid, and that's all
//
// Parameters:
// REFIID - [in] interface they want
// void ** - [out] where they want to put the resulting object ptr.
//
// Output:
// HRESULT - S_OK, E_NOINTERFACE
//
// Notes:
//
HRESULT CStandardEnum::InternalQueryInterface
(
REFIID riid,
void **ppvObjOut
)
{
if (DO_GUIDS_MATCH(riid, m_iid)) {
ExternalAddRef();
*ppvObjOut = (IEnumGeneric *)this;
return S_OK;
}
return E_NOINTERFACE;
}
COM_METHOD CorpubPublish::QueryInterface(REFIID id, void **ppInterface)
{
if (id == IID_ICorPublish)
*ppInterface = (ICorPublish*)this;
else if (id == IID_IUnknown)
*ppInterface = (IUnknown*)(ICorPublish*)this;
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
ExternalAddRef();
return S_OK;
}
//-----------------------------------------------------------------------------
// Implement IUnknown::QueryInterface.
//-----------------------------------------------------------------------------
HRESULT CordbMDA::QueryInterface(REFIID riid, void **ppInterface)
{
if (riid == IID_ICorDebugMDA)
*ppInterface = static_cast<ICorDebugMDA*>(this);
else if (riid == IID_IUnknown)
*ppInterface = static_cast<IUnknown*>(static_cast<ICorDebugMDA*>(this));
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
ExternalAddRef();
return S_OK;
}
HRESULT CordbAssembly::QueryInterface(REFIID id, void **ppInterface)
{
if (id == IID_ICorDebugAssembly)
*ppInterface = static_cast<ICorDebugAssembly*>(this);
else if (id == IID_ICorDebugAssembly2)
*ppInterface = static_cast<ICorDebugAssembly2*>(this);
else if (id == IID_IUnknown)
*ppInterface = static_cast<IUnknown*>( static_cast<ICorDebugAssembly*>(this) );
else
{
*ppInterface = NULL;
return E_NOINTERFACE;
}
ExternalAddRef();
return S_OK;
}
BOOL CSpaceshipFactory::ExternalQueryInterface(int nIid, void** ppvObj)
{
TRACE("Entering CSpaceshipFactory::ExternalQueryInterface - ID: %d\n", nIid);
switch(nIid)
{
case IID_IUnknown:
case IID_IClassFactory:
*ppvObj = &m_xClassFactory;
break;
default:
*ppvObj = NULL;
return FALSE;
}
ExternalAddRef();
return TRUE;
}
BOOL CSpaceship::ExternalQueryInterface(int nIid, void** ppvObj)
{
TRACE("Entering CSpaceship::ExternalQueryInterface - ID: %d\n", nIid);
switch(nIid)
{
case IID_IUnknown:
case IID_IMotion:
*ppvObj = &m_xMotion;
break;
case IID_IVisual:
*ppvObj = &m_xVisual;
break;
default:
*ppvObj = NULL;
return FALSE;
}
ExternalAddRef();
return TRUE;
}
//-----------------------------------------------------------------------------
// Standard IUnknown::QI implementation.
// See IUnknown::QI for standard semantics.
//-----------------------------------------------------------------------------
HRESULT CordbClass::QueryInterface(REFIID id, void **pInterface)
{
if (id == IID_ICorDebugClass)
{
*pInterface = static_cast<ICorDebugClass*>(this);
}
else if (id == IID_ICorDebugClass2)
{
*pInterface = static_cast<ICorDebugClass2*>(this);
}
else if (id == IID_IUnknown)
{
*pInterface = static_cast<IUnknown*>(static_cast<ICorDebugClass*>(this));
}
else
{
*pInterface = NULL;
return E_NOINTERFACE;
}
ExternalAddRef();
return S_OK;
}
STDMETHODIMP_(ULONG) CFolderDialog::AddRef()
{
//BFTRACE(_T("CFolderDialog(%p)::AddRef\n"),this);
return ExternalAddRef();
}
// IDispatch implementation
void CoAuthServiceCall::ReadyStateChange()
{
const DWORD dwRef = ExternalAddRef(); // lock protect your instance
try
{
switch (m_spRequest->readyState) {
case READYSTATE_LOADING:
{
TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_LOADING\n", (BSTR)m_bstrUrl, m_eState);
/*
* siehe auch: kommentar zu
* CoAuthServiceCall::m_bstrAccessToken UND
* IWorkflow::AuthorizeRequest
*/
oAuthLib::IAuthorizePtr spAuthorize;
if (SUCCEEDED(GetTokenServer(&spAuthorize)))
spAuthorize->AuthorizeRequest(m_spRequest, &m_bstrAccessToken);
}
break;
case READYSTATE_COMPLETE:
{
TRACE2("CoAuthServiceCall(%ls)::IXMLDOMDocumentsEvent::OnReadyStateChange() logical state: %d, m_spRequest->readyState: READYSTATE_COMPLETE\n", (BSTR)m_bstrUrl, m_eState);
/*
* das wird erst noetig wenn wir den UseCase: Shutdown, Wait for pending requests implementieren
* CComPtr < IWorkflow > spWorkflow;
* pThis->GetWorkflow(&spWorkflow);
* spWorkflow->FinalizeRequest(m_spRequest);
*/
if (200 == m_spRequest->status)
{
m_eState = Finish;
#ifdef AUTHORIZATION_SERVER_SUPPORT_JSON
/*
* das ist natuerlich LUXUS pur bzw. schon zuviel spezialisierung. es gibt ja auch noch XML
* https://casablanca.codeplex.com/wikipage?title=JSON&referringTitle=Documentation
*
* CAUTION: this is necessary to avoid false memory leaks reported by the MFC framework;
* http://codexpert.ro/blog/2015/05/23/using-lambdas-in-mfc-applications-part-3-dealing-with-c-rest-sdk/
*/
web::json::value result = web::json::value::parse(utility::string_t(m_spRequest->responseText));
onSucceeded(result); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status
#else
onSucceeded(); // wir setzen das onSucceeded NICHT in abhaengigkeit vom m_spRequest->status
#endif
// break reference cycle, Remove sink from xml http request
// CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt)
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
else if (401 == m_spRequest->status && InitialRequest == m_eState)
{
oAuthLib::IAuthorizePtr spAuthorize;
if (SUCCEEDED(GetTokenServer(&spAuthorize)))
{
const HRESULT _hr = spAuthorize->raw_CanRetryImmediately(m_spRequest, m_bstrAccessToken);
_ASSERT(SUCCEEDED(_hr)); // per definition gibt es hier KEIN E_FAIL/E_NOTIMPL ...
if (S_FALSE == _hr)
{
/*
* der ERSTE request der ein 401 empfaengt bzw. ALLE folge requests, die beendet wurden OHNE das wir bereits ein NEUES GUELTIGES access_token haben, laufen hier rein.
* werden vom client bzw. den clients die requests schneller abgesetzt als ein ExchangeToken() mit gueltigem access_token zurueckkommt muss der second try gequeued werden.
*/
ASSERT(NULL == m_pRenewTokenAsync);
m_pRenewTokenAsync = DYNAMIC_DOWNCAST(CoAuthRenewTokenAsync, RUNTIME_CLASS(CoAuthRenewTokenAsync)->CreateObject());
ASSERT(1 == m_pRenewTokenAsync->m_dwRef);
/*
* dieses object kuemmert sich transparent und OHNE jegliches zutun des programmieres
* darum das es einen pThis->onSucceeded() bzw. pThis->onFailed(); gibt
* diese referenz MUSS VOR dem aufruf von ::Init() gelockt anschliessend freigegeben UND NICHT gespeichert werden!
* Hinweis: ein per CRunntimeClass::CreateObject()) erzeugtes object hat initial 1 == CCmdTarget::m_dwRef
*/
{
oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback)));
ASSERT(CCmdTarget::m_dwRef == dwRef + 1);
m_pRenewTokenAsync->Init(spAuthorize, spCallback);
ASSERT(CCmdTarget::m_dwRef == dwRef + 2);
}
}
else
{
/*
* wir haben bereits ein NEUES GUELTIGES access_token empfangen.
* wir koennen diesen request SOFORT neu anstossen. MUSS NATUERLICH ASYNC sein.
*/
// wir loeschen das alte/unbrauchbare access_token aus dem initialen request
m_bstrAccessToken.Empty();
// mit IRenewCallback::Continue() wird der m_spRequest NEU initialisiert und indirekt ueber IWorkflow::AuthorizeRequest() wieder authorisiert.
oAuthLib::IRenewCallbackPtr spCallback(GetInterface(&__uuidof(oAuthLib::IRenewCallback)));
spCallback->Continue();
// here we go: NEUES GUELTIGES access_token
ASSERT(0 < m_bstrAccessToken.Length());
}
}
else
{
// saudummer zustand wir koennen den fehler NICHT an den aufrufer liefern
// ohne Workflow object geht nix da machen wir ganz ALLGEMEIN schluss
m_eState = Finish;
onFailed();
// break reference cycle, Remove sink from xml http request
// CAUTION: this wont work for this implementation MFC/DISPATCH (Heap corrupt)
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
}
else
{
// IRGENDEIN (unbehandelter) http-status
m_eState = Finish;
onFailed();
// break reference cycle
// Remove sink from xml http request, hie faellt evtl. die letzte referenz
// entweder KEINEN code mehr ausfuehren ODER Lock/Unlock
// m_spRequest->put_onreadystatechange(NULL);
}
}
break;
default:
TRACE2(" logical state: %d, m_spRequest->readyState: %d\n", m_eState, m_spRequest->readyState);
break;
}
}
catch (const _com_error& e)
{
TRACE0("CoAuthServiceCall::ReadyStateChange(): ignore exception keep system stable!!!\n");
}
ExternalRelease(); // unlock your instance
}
