Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

242 lines
7.2 KiB

/***************************************************************************/
/** Microsoft Windows **/
/** Copyright(c) Microsoft Corp., 1995-1996 **/
/***************************************************************************/
/****************************************************************************
events.hpp
Nov. 95 LenS
Event handler infrastructure.
CSequentialEventList assumes that all activity occurs on a single thread.
It is the responsibility of the users to do the sychronization and thread
context switches for this to happen.
****************************************************************************/
#ifndef EVENTS_INC
#define EVENTS_INC
// #include <referenc.h>
#include <inodecnt.h>
#include "ernccons.h"
#include "cuserdta.hpp"
class DCRNCConference;
class CLogicalConnection;
#define QUERY_IND_WORK_OWNER ((LPVOID) 1)
class CWorkItem
{
friend class CSequentialWorkList;
public:
CWorkItem(LPVOID pOwner) : m_pOwner(pOwner) { }
virtual CWorkItem::~CWorkItem(void) = 0;
virtual void DoWork(void) = 0;
BOOL IsOwnedBy(LPVOID pOwner) { return (pOwner == m_pOwner);};
protected:
LPVOID m_pOwner;
};
// Invited by a remote node.
class CInviteIndWork : public CWorkItem
{
public:
CInviteIndWork(PCONFERENCE pConference,
LPCWSTR wszCallerID,
CLogicalConnection * _pConEntry);
~CInviteIndWork(void);
void DoWork(void);
LPWSTR GetCallerID(void) {return m_pwszCallerID;};
private:
PCONFERENCE m_pConf;
LPWSTR m_pwszCallerID;
BOOL m_fSecure;
};
// joined by a remote node
class CJoinIndWork : public CWorkItem
{
public:
CJoinIndWork(GCCResponseTag Tag,
PCONFERENCE pConference,
LPCWSTR wszCallerID,
CLogicalConnection *pConEntry,
HRESULT *pRetCode);
~CJoinIndWork(void);
void DoWork(void);
HRESULT Respond(GCCResult Result);
PCONFERENCE GetConference(void) { return m_pConf; };
LPWSTR GetCallerID(void) { return m_pwszCallerID; };
CLogicalConnection *GetConEntry(void) { return m_pConEntry; };
private:
GCCResponseTag m_nResponseTag;
PCONFERENCE m_pConf;
LPWSTR m_pwszCallerID;
CLogicalConnection *m_pConEntry;
};
class CQueryRemoteWork : public CWorkItem
{
public:
CQueryRemoteWork(LPVOID pContext, GCCAsymmetryType, LPCSTR pcszNodeAddr, BOOL fSecure, HRESULT *);
~CQueryRemoteWork(void);
void DoWork(void);
void HandleQueryConfirmation(QueryConfirmMessage * pQueryMessage);
void SyncQueryRemoteResult(void);
void AsyncQueryRemoteResult(void);
int GenerateRand(void);
void SetHr(HRESULT hr) { m_hr = hr; }
BOOL IsInUnknownQueryRequest(void) { return m_fInUnknownQueryRequest; }
ConnectionHandle GetConnectionHandle(void) { return m_hGCCConnHandle; }
void GetAsymIndicator ( GCCAsymmetryIndicator *pIndicator )
{
pIndicator->asymmetry_type = m_LocalAsymIndicator.asymmetry_type;
pIndicator->random_number = m_LocalAsymIndicator.random_number;
}
private:
ConnectionHandle m_hGCCConnHandle;
GCCAsymmetryType m_eAsymType;
LPSTR m_pszAddress;
LPWSTR *m_apConfNames;
HRESULT m_hr;
BOOL m_fRemoteIsMCU;
GCCAsymmetryIndicator m_LocalAsymIndicator;
BOOL m_fInUnknownQueryRequest;
int m_nRandSeed;
BOOL m_fSecure;
LPWSTR *m_apConfDescriptors;
};
// The CSequentialWorkList class is used to process a series
// of asynchronous requests one at a time.
// The user subclasses CWorkItem and puts the CWorkItem object into
// the list by calling CSequentialWorkList::Add().
// When it is its turn to be processed (i.e. there are no pending requests),
// CWorkItem::Handle() is called. When the asynchonous work is done,
// the user calls CSequentialWorkList::Remove which takes the CWorkItem
// object out of the list, destroys it and calls CWorkItem::Handle() for
// the next CWorkItem in the list (if any).
class CSequentialWorkList : public CList
{
DEFINE_CLIST(CSequentialWorkList, CWorkItem*)
public:
~CSequentialWorkList(void)
{
// Don't want to destroy an event list with pending events.
// Codework: build I/O rundown into a generic event list,
// and subclass.
ASSERT(IsEmpty());
}
void AddWorkItem(CWorkItem * pWorkItem);
void RemoveWorkItem(CWorkItem * pWorkItem);
void PurgeListEntriesByOwner(DCRNCConference *pOwner);
void DeleteList(void);
};
#define DEFINE_SEQ_WORK_LIST(_NewClass_,_PtrItemType_) \
public: \
_NewClass_(UINT cMaxItems = CLIST_DEFAULT_MAX_ITEMS) : CSequentialWorkList(cMaxItems) { ASSERT(sizeof(_PtrItemType_) == sizeof(CWorkItem*)); } \
_NewClass_(_NewClass_ *pSrc) : CSequentialWorkList((CSequentialWorkList *) pSrc) { ASSERT(sizeof(_PtrItemType_) == sizeof(CWorkItem*)); } \
_NewClass_(_NewClass_ &Src) : CSequentialWorkList((CSequentialWorkList *) &Src) { ASSERT(sizeof(_PtrItemType_) == sizeof(CWorkItem*)); } \
BOOL Append(_PtrItemType_ pData) { return CSequentialWorkList::Append((CWorkItem*) pData); } \
BOOL Prepend(_PtrItemType_ pData) { return CSequentialWorkList::Prepend((CWorkItem*) pData); } \
BOOL Remove(_PtrItemType_ pData) { return CSequentialWorkList::Remove((CWorkItem*) pData); } \
BOOL Find(_PtrItemType_ pData) { return CSequentialWorkList::Find((CWorkItem*) pData); } \
_PtrItemType_ Get(void) { return (_PtrItemType_) CSequentialWorkList::Get(); } \
_PtrItemType_ PeekHead(void) { return (_PtrItemType_) CSequentialWorkList::PeekHead(); } \
_PtrItemType_ Iterate(void) { return (_PtrItemType_) CSequentialWorkList::Iterate(); }
class CInviteIndWorkList : public CSequentialWorkList
{
DEFINE_SEQ_WORK_LIST(CInviteIndWorkList, CInviteIndWork*)
public:
void AddWorkItem(CInviteIndWork * pWorkItem)
{
CSequentialWorkList::AddWorkItem(pWorkItem);
}
void RemoveWorkItem(CInviteIndWork * pWorkItem)
{
CSequentialWorkList::RemoveWorkItem(pWorkItem);
}
};
class CJoinIndWorkList : public CSequentialWorkList
{
DEFINE_SEQ_WORK_LIST(CJoinIndWorkList, CJoinIndWork*)
public:
void AddWorkItem(CJoinIndWork * pWorkItem)
{
CSequentialWorkList::AddWorkItem(pWorkItem);
}
void RemoveWorkItem(CJoinIndWork * pWorkItem)
{
CSequentialWorkList::RemoveWorkItem(pWorkItem);
}
};
class CQueryRemoteWorkList : public CSequentialWorkList
{
DEFINE_SEQ_WORK_LIST(CQueryRemoteWorkList, CQueryRemoteWork*)
public:
void AddWorkItem(CQueryRemoteWork * pWorkItem)
{
CSequentialWorkList::AddWorkItem(pWorkItem);
}
void RemoveWorkItem(CQueryRemoteWork * pWorkItem)
{
CSequentialWorkList::RemoveWorkItem(pWorkItem);
}
HRESULT Cancel ( LPVOID pCallerContext );
};
extern CQueryRemoteWorkList *g_pQueryRemoteList;
#endif /* ndef EVENTS_INC */