189 lines
4.5 KiB
C++
189 lines
4.5 KiB
C++
#ifndef _COOKIE_HXX_
|
|
#define _COOKIE_HXX_
|
|
#ifdef __cplusplus
|
|
|
|
#ifdef unix
|
|
#include "../download/packet.hxx"
|
|
#endif /* unix */
|
|
|
|
// CCookie<TYPE>
|
|
// This is a template for implementing a typesafe cookie that will prevent
|
|
// re-entrancy by the same thread. Eg. when a thread posts a dialog box it
|
|
// can still receive messages and can reenter a msg handler that
|
|
// put up the dialog if not protected. This is a case with us putting up
|
|
// WinVerifyTrust dialogs from OnStopBinding in code download. We want to
|
|
// serialize this across different code downloads on the same thread and
|
|
// different dependent piece downloads within the same code download.
|
|
// we also use this to serialize the setup phase making sure only one code
|
|
// download per thread is in setup phase
|
|
|
|
// Rules:
|
|
// to enter either the setup phase or to verify trust of a component
|
|
// you need to acquire the corresponding cookie in tls.
|
|
// pcookie->Acquire()
|
|
// returns S_Ok if you grabbed the cookie successfully
|
|
// returns S_FALSE if cookie is busy. You must return from the
|
|
// msg handler and then a packet will get posted to you
|
|
// with (wParam = id passed in, lParam (fixed for cookie obj)
|
|
// when you pCookie->Relinquish() the next client on line will be posted a pkt
|
|
|
|
template<class TYPE>
|
|
class CCookie
|
|
{
|
|
|
|
public:
|
|
CCookie(DWORD msg);
|
|
|
|
BOOL IsFree() const;
|
|
BOOL IsOwner(TYPE id) const;
|
|
|
|
HRESULT Acquire(TYPE id);
|
|
HRESULT Relinquish(TYPE id);
|
|
|
|
HRESULT JITAcquire();
|
|
HRESULT JITRelinquish();
|
|
|
|
HRESULT TickleWaitList();
|
|
|
|
private:
|
|
|
|
TYPE m_owner;
|
|
|
|
CList<TYPE,TYPE> m_pWaitList; // linked list of waiting clients
|
|
|
|
DWORD m_msg; // client that gets cookie
|
|
|
|
// wParam is the id (TYPE)
|
|
DWORD m_lParam;
|
|
|
|
BOOL m_bJITAcquired;
|
|
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCookie<TYPE> functions
|
|
|
|
template<class TYPE>
|
|
CCookie<TYPE>::CCookie(DWORD msg):m_owner(NULL),m_lParam(0)
|
|
{
|
|
m_msg = msg;
|
|
|
|
m_pWaitList.RemoveAll();
|
|
|
|
m_bJITAcquired = FALSE;
|
|
}
|
|
|
|
template<class TYPE>
|
|
BOOL CCookie<TYPE>::IsOwner(TYPE id) const
|
|
{ return (id == m_owner); }
|
|
|
|
template<class TYPE>
|
|
BOOL CCookie<TYPE>::IsFree() const
|
|
{ return ((NULL == m_owner) && !m_bJITAcquired); }
|
|
|
|
// pcookie->Acquire()
|
|
// returns S_Ok if you grabbed the cookie successfully
|
|
// returns S_FALSE if cookie is busy. You must return from the
|
|
// msg handler and then a packet will get posted to you
|
|
// with (wParam = id passed in, lParam (fixed for cookie obj)
|
|
|
|
template<class TYPE>
|
|
HRESULT CCookie<TYPE>::Acquire(TYPE id)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
Assert(id);
|
|
|
|
if (m_bJITAcquired || ((m_owner != NULL) && (m_owner != id))) {
|
|
|
|
// add iff not already in list
|
|
if (m_pWaitList.Find(id) == NULL)
|
|
m_pWaitList.AddTail(id);
|
|
|
|
hr = S_FALSE;
|
|
|
|
} else {
|
|
|
|
m_owner = id; // assign cookie
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// pCookie->Relinquish(): free the cookie
|
|
// and the next client on line will get the cookie and be posted a packet
|
|
// with (wParam = id passed in, lParam (fixed for cookie obj)
|
|
template<class TYPE>
|
|
HRESULT CCookie<TYPE>::Relinquish(TYPE id)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Assert(id);
|
|
Assert(m_owner);
|
|
Assert(m_owner == id);
|
|
|
|
if ((m_owner == NULL) || (m_owner != id)) {
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
hr = TickleWaitList();
|
|
Assert(SUCCEEDED(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
template<class TYPE>
|
|
HRESULT CCookie<TYPE>::TickleWaitList()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_pWaitList.GetCount() > 0)
|
|
m_owner = m_pWaitList.RemoveHead();
|
|
else
|
|
m_owner = NULL;
|
|
|
|
// if m_owner, post message to this new owner
|
|
if (m_owner) {
|
|
|
|
CCDLPacket *pPkt= new CCDLPacket(m_msg, m_owner, (DWORD)m_lParam);
|
|
|
|
if (pPkt) {
|
|
hr = pPkt->Post();
|
|
} else {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
}
|
|
|
|
Assert(SUCCEEDED(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
template<class TYPE>
|
|
HRESULT CCookie<TYPE>::JITAcquire()
|
|
{
|
|
Assert(m_owner == NULL);
|
|
|
|
m_bJITAcquired = TRUE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
template<class TYPE>
|
|
HRESULT CCookie<TYPE>::JITRelinquish()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Assert(m_owner == NULL);
|
|
|
|
m_bJITAcquired = FALSE;
|
|
|
|
hr = TickleWaitList();
|
|
Assert(SUCCEEDED(hr));
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
#endif
|