1098 lines
38 KiB
C
1098 lines
38 KiB
C
/*
|
|
* NOTIFY.C
|
|
*
|
|
* WAB Notification Engine
|
|
*
|
|
* Copyright 1996 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
*
|
|
* Notification in the WAB works as follows:
|
|
* Client apps call Advise to register their interest in particular
|
|
* notifications. The wab maintains a local list of the notifications
|
|
* that the client has advised in the processes heap. The wab also
|
|
* maintains a thread while there are any active advise sessions. This
|
|
* thread waits on the global notification event.
|
|
*
|
|
* When a notification event happens (through HrFireNotification)
|
|
* the event is written into a shared memory list and the global
|
|
* notification event is triggered.
|
|
*
|
|
* The client thread (one in each process) wakes when this event is
|
|
* triggered and compares the shared memory list of events against
|
|
* it's local list of advises. If a match is found, the thread calls
|
|
* the advise's OnNotify callback.
|
|
*
|
|
* There is a reference count in the global notification list's records
|
|
* so that the record can be cleaned up when all processes have had
|
|
* a chance to see it.
|
|
*
|
|
*/
|
|
|
|
#include "_apipch.h"
|
|
|
|
#define ADVISE_TIMEOUT 60000 // milliseconds
|
|
|
|
|
|
// #define NEW_STUFF
|
|
#ifdef NEW_STUFF
|
|
|
|
#define NOTIFY_CREATE_TIMEOUT 60000 // milliseconds
|
|
#define FIRE_NOTIFY_TIMEOUT 10000 // milliseconds
|
|
#define ADVISE_THREAD_TIMEOUT ((ULONG)-1) // Forever
|
|
#define NOTIFY_ADVISE_TIMEOUT 60000 // milliseconds
|
|
|
|
// Per-process globals
|
|
// 0 1 2
|
|
// 012345678901234567890123
|
|
const TCHAR szNotificationName[] = "_MICROSOFT_WAB_NOTIFY_";
|
|
const TCHAR szMEM[] = "MEM"; // suffix for shared memory
|
|
const TCHAR szEVT[] = "EVT"; // suffix for event
|
|
const TCHAR szMTX[] = "MTX"; // suffix for mutex
|
|
|
|
LPNOTIFICATION_LIST lpNotificationList = NULL;
|
|
HANDLE hmemNotificationList = NULL;
|
|
HANDLE hevNotificationList = NULL;
|
|
HANDLE hmtxNotificationList = NULL;
|
|
HANDLE hevNotificationUI = NULL;
|
|
HANDLE hmtxAdviseList = NULL;
|
|
|
|
ADVISE_LIST AdviseList = {0, NULL};
|
|
HANDLE hevKillAdvise = NULL;
|
|
ULONG ulMaxIdentifierSeen = 0;
|
|
|
|
// Forward declarations
|
|
DWORD AdviseThread(LPDWORD lpdwParam);
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : WaitForTwoObjects
|
|
|
|
Purpose : Wait for one of two objects to be signalled
|
|
|
|
Parameters: handle0 = first object handle
|
|
handle1 = second object handle
|
|
dwTimeout = timeout in milliseconds
|
|
|
|
Returns : index of object or -1 on error (0, 1 or -1)
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
ULONG WaitForTwoObjects(HANDLE handle0, HANDLE handle1, DWORD dwTimeout) {
|
|
HANDLE rgHandles[2] = {handle0, handle1};
|
|
|
|
switch (WaitForMultipleObjects(2, rgHandles, FALSE, dwTimeout)) {
|
|
case WAIT_ABANDONED_0:
|
|
DebugTrace("WaitFoMultipleObjects got WAIT_ABANDONED_0\n");
|
|
case WAIT_OBJECT_0:
|
|
return(0);
|
|
|
|
case WAIT_ABANDONED_0 + 1:
|
|
DebugTrace("WaitFoMultipleObjects got WAIT_ABANDONED_1\n");
|
|
case WAIT_OBJECT_0 + 1:
|
|
return(1);
|
|
|
|
case WAIT_FAILED:
|
|
default:
|
|
DebugTrace("WaitForMultipleObjects got WAIT_FAILED: %u\n", GetLastError());
|
|
case WAIT_TIMEOUT:
|
|
return((ULONG)-1);
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CompareEntryIDs
|
|
|
|
Purpose : Are the two entryID's the same?
|
|
|
|
Parameters: cbEntryID1 = sizeof lpEntryID1
|
|
lpEntryID1 = first EntryID
|
|
cbEntryID2 = sizeof lpEntryID2
|
|
lpEntryID2 = second EntryID
|
|
|
|
Returns : TRUE if the entry IDs are the same
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
BOOL CompareEntryIDs(ULONG cbEntryID1,
|
|
LPENTRYID lpEntryID1,
|
|
ULONG cbEntryID2,
|
|
LPENTRYID lpEntryID2)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
|
|
if (cbEntryID1 == cbEntryID2) {
|
|
if (cbEntryID1 && 0 == memcmp((LPVOID)lpEntryID1, (LPVOID)lpEntryID2,
|
|
(size_t)cbEntryID1)) {
|
|
fReturn = TRUE;
|
|
}
|
|
}
|
|
|
|
return(fReturn);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : CreateNotifySession
|
|
|
|
Purpose : Create/Open the notification lists and thread.
|
|
|
|
Parameters: lpfExisted -> returned flag TRUE if the session
|
|
was already setup for this process.
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : Fills in these globals:
|
|
hmtxNotificationList
|
|
hevNotificationList
|
|
hmemNotificationList
|
|
lpNotificationList
|
|
|
|
***************************************************************************/
|
|
HRESULT CreateNotifySession(LPBOOL lpfExisted) {
|
|
HRESULT hResult = hrSuccess;
|
|
BOOL fMutex = FALSE;
|
|
DWORD dwThreadId;
|
|
DWORD dwThreadParam = 0;
|
|
HANDLE hthrdAdvise = NULL;
|
|
TCHAR szName[CharSizeOf(szNotificationName) + CharSizeOf(szMEM)];
|
|
|
|
Assert(CharSizeOf(szMEM) == CharSizeOf(szEVT) && CharSizeOf(szEVT) == CharSizeOf(szMTX));
|
|
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBuff(szName, szMTX, ARRAYSIZE(szName));
|
|
if (! (hmtxNotificationList = CreateMutex(NULL,
|
|
FALSE,
|
|
szName))) {
|
|
DebugTrace("CreateNotifySession:CreateMutex(%s) -> %u\n", szName, GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
if (hResult = HrWaitForObject(hmtxNotificationList, NOTIFY_CREATE_TIMEOUT)) {
|
|
DebugTrace("CreateNotifySession:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fMutex = TRUE;
|
|
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBuff(szName, szMEM, ARRAYSIZE(szName));
|
|
if ((hmemNotificationList = CreateFileMapping(INVALID_HANDLE_VALUE, // handle
|
|
NULL, // security descriptor
|
|
PAGE_READWRITE, // reserve more
|
|
0, // max size high
|
|
MAX_NOTIFICATION_SPACE, // max size low
|
|
szName)) == NULL) { // name
|
|
DebugTrace("CreateNotifySession: CreateFileMapping(%s) --> %u\n",
|
|
szName, GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
*lpfExisted = (GetLastError() == ERROR_ALREADY_EXISTS);
|
|
|
|
if ((lpNotificationList = (LPNOTIFICATION_LIST)MapViewOfFile(hmemNotificationList,
|
|
FILE_MAP_WRITE | FILE_MAP_READ,
|
|
0,
|
|
0,
|
|
sizeof(NOTIFICATION_LIST))) == NULL) {
|
|
DebugTrace("CreateNotifySession: CreateFileMapping --> %u\n",
|
|
GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
if (! *lpfExisted) {
|
|
// Initialize global notification list
|
|
lpNotificationList->cAdvises = 0; // Number of advise processes
|
|
lpNotificationList->cEntries = 0; // Number of entries in the list
|
|
lpNotificationList->lpNode = NULL; // First node in list or NULL if empty
|
|
lpNotificationList->ulNextIdentifier = 1; // next value for a notification identifier
|
|
}
|
|
lpNotificationList->cAdvises++; // Number of advise processes
|
|
|
|
// Notification Event
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBUff(szName, szEVT, ARRAYSIZE(szName));
|
|
if (! (hevNotificationList = CreateEvent(NULL,
|
|
TRUE, // Manual reset
|
|
FALSE, // initial state (not triggered)
|
|
szName))) {
|
|
DebugTrace("CreateNotifySession:CreateEvent(%S) -> %u\n", szName, GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
// Advise Kill Event
|
|
if (! (hevKillAdvise = CreateEvent(NULL,
|
|
TRUE, // Manual reset
|
|
FALSE, // initial state (not triggered)
|
|
NULL))) {
|
|
DebugTrace("CreateNotifySession:CreateEvent(Kill Advise) -> %u\n", GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
// Create the Local AdviseList
|
|
if (! (hmtxAdviseList = CreateMutex(NULL,
|
|
FALSE, // Not initially owned
|
|
NULL))) { // no name
|
|
DebugTrace("CreateNotifySession:CreateMutex(Advise List) -> %u\n", GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
// Local AdviseList should be empty
|
|
Assert(AdviseList.cAdvises == 0);
|
|
Assert(AdviseList.lpNode == NULL);
|
|
|
|
// Create the Advise thread for this process
|
|
if (! (hthrdAdvise = CreateThread(NULL, // no security attributes
|
|
0, // default stack size: BUGBUG: Should be smaller
|
|
(LPTHREAD_START_ROUTINE)AdviseThread, // thread function
|
|
&dwThreadParam, // argument to thread
|
|
0, // flags
|
|
&dwThreadId))) {
|
|
DebugTrace("CreateNotifySession:CreateThread -> %u\n", GetLastError());
|
|
// propbably out of memory?
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
if (fMutex) {
|
|
ReleaseMutex(hmtxNotificationList);
|
|
}
|
|
if (hthrdAdvise) {
|
|
CloseHandle(hthrdAdvise);
|
|
}
|
|
if (hResult) {
|
|
// Failure, clean up
|
|
if (lpNotificationList) {
|
|
UnmapViewOfFile(lpNotificationList);
|
|
lpNotificationList = NULL;
|
|
}
|
|
if (hmemNotificationList) {
|
|
CloseHandle(hmemNotificationList);
|
|
hmemNotificationList = NULL;
|
|
}
|
|
if (hmtxNotificationList) {
|
|
CloseHandle(hmtxNotificationList);
|
|
hmtxNotificationList = NULL;
|
|
}
|
|
if (hevNotificationList) {
|
|
CloseHandle(hevNotificationList);
|
|
hevNotificationList = NULL;
|
|
}
|
|
if (hevKillAdvise) {
|
|
CloseHandle(hevKillAdvise);
|
|
hevKillAdvise = NULL;
|
|
}
|
|
}
|
|
|
|
return(hResult);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : OpenNotifySession
|
|
|
|
Purpose : Open the global notification list, if it exists.
|
|
|
|
Parameters: lppNotificationList -> returned notification list
|
|
lphmemNotificationList -> returned shared memory handle
|
|
lphmtxNotificationList -> returned Mutex handle
|
|
lphevNotificationList -> returned event handle
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : This function does not effect the globals!
|
|
|
|
***************************************************************************/
|
|
HRESULT OpenNotifySession(LPNOTIFICATION_LIST * lppNotificationList,
|
|
LPHANDLE lphmemNotificationList,
|
|
LPHANDLE lphmtxNotificationList,
|
|
LPHANDLE lphevNotificationList) {
|
|
HRESULT hResult = hrSuccess;
|
|
BOOL fMutex = FALSE;
|
|
TCHAR szName[CharSizeOf(szNotificationName) + CharSizeOf(szMEM)];
|
|
|
|
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBuff(szName, szMTX, ARRAYSIZE(szName));
|
|
if (! (*lphmtxNotificationList = OpenMutex(SYNCHRONIZE,
|
|
FALSE, // inherit handle?
|
|
szName))) {
|
|
DebugTrace("OpenNotifySession:OpenMutex(%s) -> %u\n", szName, GetLastError());
|
|
// No Advise sessions exist, don't bother with this.
|
|
hResult = ResultFromScode(WAB_W_NO_ADVISE);
|
|
goto exit;
|
|
}
|
|
|
|
if (hResult = HrWaitForObject(*lphmtxNotificationList, NOTIFY_CREATE_TIMEOUT)) {
|
|
DebugTrace("CreateNotifySession:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fMutex = TRUE;
|
|
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBuff(szName, szMEM, ARRAYSIZE(szName));
|
|
if ((*lphmemNotificationList = CreateFileMapping(INVALID_HANDLE_VALUE, // handle
|
|
NULL, // security descriptor
|
|
PAGE_READWRITE | SEC_RESERVE, // reserve more
|
|
0, // max size high
|
|
MAX_NOTIFICATION_SPACE, // max size low
|
|
szName)) == NULL) { // name
|
|
DebugTrace("CreateNotifySession: CreateFileMapping --> %u\n",
|
|
GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
if ((*lppNotificationList = (LPNOTIFICATION_LIST)MapViewOfFile(*lphmemNotificationList,
|
|
FILE_MAP_WRITE | FILE_MAP_READ,
|
|
0,
|
|
0,
|
|
sizeof(NOTIFICATION_LIST))) == NULL) {
|
|
DebugTrace("CreateNotifySession: CreateFileMapping --> %u\n",
|
|
GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
// Initialize global notification list
|
|
Assert((*lppNotificationList)->cAdvises != 0); // Number of advise processes
|
|
|
|
// Notification Event
|
|
StrCpyN(szName, szNotificationName, ARRAYSIZE(szName));
|
|
StrCatBuff(szName, szEVT, ARRAYSIZE(szName));
|
|
if (! (*lphevNotificationList = CreateEvent(NULL,
|
|
TRUE, // Manual reset
|
|
FALSE, // initial state (not triggered)
|
|
szName))) {
|
|
DebugTrace("OpenNotifySession:CreateEvent(%S) -> %u\n", szName, GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
if (fMutex) {
|
|
ReleaseMutex(*lphmtxNotificationList);
|
|
}
|
|
if (hResult) {
|
|
// Failure, clean up
|
|
if (*lphmemNotificationList) {
|
|
CloseHandle(*lphmemNotificationList);
|
|
*lphmemNotificationList = NULL;
|
|
}
|
|
|
|
if (*lphmtxNotificationList) {
|
|
CloseHandle(*lphmtxNotificationList);
|
|
*lphmtxNotificationList = NULL;
|
|
}
|
|
if (*lphevNotificationList) {
|
|
CloseHandle(*lphevNotificationList);
|
|
*lphevNotificationList = NULL;
|
|
}
|
|
}
|
|
|
|
return(hResult);
|
|
}
|
|
#endif // NEW_STUFF
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : HrWaitForObject
|
|
|
|
Purpose : Wait for an object to be signalled
|
|
|
|
Parameters: handle = object handle
|
|
dwTimeout = timeout in milliseconds
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT HrWaitForObject(HANDLE handle, DWORD dwTimeout) {
|
|
switch (WaitForSingleObject(handle, dwTimeout)) {
|
|
case WAIT_ABANDONED:
|
|
DebugTrace(TEXT("WARNING:HrWaitForObject got WAIT_ABANDONED\n"));
|
|
// fall through to success
|
|
case WAIT_OBJECT_0:
|
|
return(hrSuccess);
|
|
case WAIT_TIMEOUT:
|
|
DebugTrace(TEXT("HrWaitForObject timed out\n"));
|
|
return(ResultFromScode(MAPI_E_TIMEOUT));
|
|
case WAIT_FAILED:
|
|
default:
|
|
DebugTrace(TEXT("HrWaitForObject failed -> %u\n"), GetLastError());
|
|
return(ResultFromScode(MAPI_E_CALL_FAILED));
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : HrWABNotify
|
|
|
|
Purpose : Scans registered clients and Notifies them of a store modification
|
|
The first-cut at notifications is extremely simplistic. Any time
|
|
the WAB store changes, we fire off a store notification. No attempt
|
|
to check eventmasks or entryids etc
|
|
|
|
Parameters: lpIAB = THIS object
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : What happens in here:
|
|
|
|
***************************************************************************/
|
|
HRESULT HrWABNotify(LPIAB lpIAB)
|
|
{
|
|
HRESULT hResult = hrSuccess;
|
|
|
|
LPADVISE_NODE lpAdviseNode = NULL;
|
|
NOTIFICATION WABNotif = {0};
|
|
|
|
EnterCriticalSection(&lpIAB->cs);
|
|
|
|
if (!lpIAB->pWABAdviseList ||
|
|
!lpIAB->pWABAdviseList->cAdvises)
|
|
{
|
|
hResult = ResultFromScode(MAPI_E_NOT_FOUND);
|
|
goto exit;
|
|
}
|
|
|
|
|
|
// Since calling applications may have no idea of container/folder changes, but may
|
|
// call container based methods ..
|
|
// update the list of WAB containers for that applicaiton so that GetContentsTable etc
|
|
// will work correctly ..
|
|
if(bAreWABAPIProfileAware(lpIAB))
|
|
HrGetWABProfiles(lpIAB);
|
|
|
|
WABNotif.ulEventType = fnevObjectModified;
|
|
WABNotif.info.obj.ulObjType = MAPI_ADDRBOOK;
|
|
WABNotif.info.obj.cbEntryID = WABNotif.info.obj.cbParentID =
|
|
WABNotif.info.obj.cbOldID = WABNotif.info.obj.cbOldParentID = 0;
|
|
WABNotif.info.obj.lpEntryID = WABNotif.info.obj.lpParentID =
|
|
WABNotif.info.obj.lpOldID = WABNotif.info.obj.lpOldParentID = NULL;
|
|
WABNotif.info.obj.lpPropTagArray = NULL;
|
|
|
|
lpAdviseNode = lpIAB->pWABAdviseList->lpNode;
|
|
while(lpAdviseNode)
|
|
{
|
|
lpAdviseNode->lpAdviseSink->lpVtbl->OnNotify(lpAdviseNode->lpAdviseSink,
|
|
1,
|
|
&WABNotif);
|
|
lpAdviseNode = lpAdviseNode->lpNext;
|
|
}
|
|
|
|
exit:
|
|
|
|
LeaveCriticalSection(&lpIAB->cs);
|
|
|
|
return(hResult);
|
|
|
|
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
Name : HrAdvise
|
|
|
|
Purpose : Performs client notification registration
|
|
|
|
Parameters: lpIAB = THIS object
|
|
cbEntryID = sizeof lpEntryID
|
|
lpEntryID -> EntryID of object about which notifications
|
|
should be generated.
|
|
ulEventMask = events about which to generate notifications
|
|
fnevObjectCreated
|
|
fnevObjectDeleted
|
|
fnevObjectModified
|
|
fnevTableModified
|
|
NOTE: WAB currently does not support fnevCriticalError,
|
|
fnevObjectCopied or fnevObjectMoved.
|
|
lpAdviseSink -> Client's advise sink object
|
|
lpulConnection -> returned connection number (client should
|
|
save to pass to Unadvise.)
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : What happens in here:
|
|
Store the EventMask and AdviseSink in the local advise list.
|
|
If there are no other Advise sessions open in this process:
|
|
Make sure there is one and register it
|
|
|
|
***************************************************************************/
|
|
HRESULT HrAdvise(LPIAB lpIAB,
|
|
ULONG cbEntryID,
|
|
LPENTRYID lpEntryID,
|
|
ULONG ulEventMask,
|
|
LPMAPIADVISESINK lpAdvise,
|
|
ULONG FAR * lpulConnection)
|
|
{
|
|
HRESULT hResult = hrSuccess;
|
|
|
|
BOOL fExisted = FALSE;
|
|
LPADVISE_NODE lpAdviseNode = NULL, lpTemp = NULL;
|
|
static ULONG ulNextConnection = 1;
|
|
|
|
EnterCriticalSection(&lpIAB->cs);
|
|
|
|
if(!lpIAB->pWABAdviseList)
|
|
{
|
|
lpIAB->pWABAdviseList = LocalAlloc(LMEM_ZEROINIT, sizeof(ADVISE_LIST));
|
|
if(!lpIAB->pWABAdviseList)
|
|
{
|
|
hResult = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto exit;
|
|
}
|
|
lpIAB->pWABAdviseList->cAdvises = 0;
|
|
lpIAB->pWABAdviseList->lpNode = NULL;
|
|
}
|
|
|
|
lpAdviseNode = LocalAlloc(LMEM_ZEROINIT, sizeof(ADVISE_NODE) + cbEntryID);
|
|
if(!lpAdviseNode)
|
|
{
|
|
hResult = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
lpAdviseNode->ulConnection = ulNextConnection++;
|
|
lpAdviseNode->ulEventMask = ulEventMask;
|
|
lpAdviseNode->lpAdviseSink = lpAdvise;
|
|
if(cbEntryID && lpEntryID)
|
|
{
|
|
CopyMemory(&lpAdviseNode->EntryID, lpEntryID, cbEntryID);
|
|
}
|
|
|
|
lpAdviseNode->lpPrev = NULL;
|
|
lpAdviseNode->lpNext = lpIAB->pWABAdviseList->lpNode;
|
|
if(lpIAB->pWABAdviseList->lpNode)
|
|
lpIAB->pWABAdviseList->lpNode->lpPrev = lpAdviseNode;
|
|
lpIAB->pWABAdviseList->lpNode = lpAdviseNode;
|
|
lpIAB->pWABAdviseList->cAdvises++;
|
|
|
|
// Addref the LPADVISESINK pointer so we have a handle on it ...
|
|
//
|
|
lpAdvise->lpVtbl->AddRef(lpAdvise);
|
|
*lpulConnection = lpAdviseNode->ulConnection;
|
|
|
|
exit:
|
|
LeaveCriticalSection(&lpIAB->cs);
|
|
|
|
return(hResult);
|
|
|
|
|
|
#ifdef NEW_STUFF
|
|
/*
|
|
// Walk the advise list looking for the connection
|
|
// Make sure we're safe to monkey with the list
|
|
if (hResult = HrWaitForObject(hmtxAdviseList, ADVISE_TIMEOUT))
|
|
{
|
|
DebugTrace("HrUnadvise:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fMutex = TRUE;
|
|
|
|
// Is there an open Advise session for this process?
|
|
// If not, set up the advise session for this process.
|
|
if (! lpNotificationList) {
|
|
if (hResult = CreateNotifySession(&fExisted)) {
|
|
DebugTraceResult( TEXT("HrAdvise:CreateNotifySession"), hResult);
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
// Add Advise info to Local Advise List.
|
|
|
|
// Create the new node
|
|
if (! (lpAdviseNode = LocalAlloc(LPTR, sizeof(ADVISE_NODE) + cbEntryID))) {
|
|
DebugTrace("LocalAlloc(%u) AdviseNode -> %u\n", sizeof(ADVISE_NODE) + cbEntryID, GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
lpAdviseNode->ulConnection = ulNextConnection++;
|
|
lpAdviseNode->lpAdviseSink = lpAdvise;
|
|
lpAdviseNode->ulEventMask = ulEventMask;
|
|
lpAdviseNode->cbEntryID = cbEntryID;
|
|
CopyMemory(&lpAdviseNode->EntryID, lpEntryID, cbEntryID);
|
|
|
|
// Add the new node to front of the list
|
|
|
|
// Make sure we're safe to monkey with the list
|
|
if (hResult = HrWaitForObject(hmtxAdviseList, ADVISE_TIMEOUT)) {
|
|
DebugTrace("HrAdvise:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fMutex = TRUE;
|
|
|
|
lpAdviseNode->lpNext = AdviseList.lpNode;
|
|
AdviseList.lpNode = lpAdviseNode;
|
|
AdviseList.cAdvises++;
|
|
*lpulConnection = lpAdviseNode->ulConnection;
|
|
|
|
exit:
|
|
if (fMutex) {
|
|
ReleaseMutex(hmtxAdviseList);
|
|
}
|
|
#else
|
|
hResult = ResultFromScode(MAPI_E_CALL_FAILED);
|
|
*/
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : HrUnadvise
|
|
|
|
Purpose : Removes an Advise from the list
|
|
|
|
Parameters: ulConnection = connection number to remove
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment :
|
|
|
|
***************************************************************************/
|
|
HRESULT HrUnadvise(LPIAB lpIAB, ULONG ulConnection) {
|
|
HRESULT hResult = hrSuccess;
|
|
|
|
BOOL fMutex = FALSE;
|
|
LPADVISE_NODE lpAdviseNode = NULL;
|
|
|
|
EnterCriticalSection(&lpIAB->cs);
|
|
|
|
if (!lpIAB->pWABAdviseList ||
|
|
!lpIAB->pWABAdviseList->cAdvises)
|
|
{
|
|
hResult = ResultFromScode(MAPI_E_NOT_FOUND);
|
|
goto exit;
|
|
}
|
|
|
|
lpAdviseNode = lpIAB->pWABAdviseList->lpNode;
|
|
|
|
while (lpAdviseNode)
|
|
{
|
|
if (lpAdviseNode->ulConnection == ulConnection)
|
|
{
|
|
if(lpIAB->pWABAdviseList->lpNode == lpAdviseNode)
|
|
lpIAB->pWABAdviseList->lpNode = lpAdviseNode->lpNext;
|
|
|
|
if(lpAdviseNode->lpPrev)
|
|
lpAdviseNode->lpPrev->lpNext = lpAdviseNode->lpNext;
|
|
if(lpAdviseNode->lpNext)
|
|
lpAdviseNode->lpNext->lpPrev = lpAdviseNode->lpPrev;
|
|
|
|
// Release the hold on this pointer ...
|
|
lpAdviseNode->lpAdviseSink->lpVtbl->Release(lpAdviseNode->lpAdviseSink);
|
|
|
|
LocalFreeAndNull(&lpAdviseNode);
|
|
|
|
lpIAB->pWABAdviseList->cAdvises--;
|
|
|
|
//Assert(lpIAB->pWABAdviseList->cAdvises == 0 && lpIAB->pWABAdviseList->lpNode == NULL);
|
|
|
|
if(!lpIAB->pWABAdviseList->cAdvises && !lpIAB->pWABAdviseList->lpNode)
|
|
{
|
|
LocalFree(lpIAB->pWABAdviseList);
|
|
lpIAB->pWABAdviseList = NULL;
|
|
}
|
|
|
|
goto exit;
|
|
}
|
|
lpAdviseNode = lpAdviseNode->lpNext;
|
|
}
|
|
|
|
hResult = ResultFromScode(MAPI_E_NOT_FOUND);
|
|
|
|
exit:
|
|
LeaveCriticalSection(&lpIAB->cs);
|
|
return(hResult);
|
|
|
|
|
|
/*
|
|
#ifdef NEW_STUFF
|
|
BOOL fMutex = FALSE;
|
|
LPADVISE_NODE lpAdviseNode = NULL;
|
|
LPADVISE_NODE * lppPrevNode = &(AdviseList.lpNode);
|
|
|
|
if (hmtxAdviseList == NULL || AdviseList.cAdvises == 0) {
|
|
hResult = ResultFromScode(MAPI_E_NOT_FOUND);
|
|
goto exit;
|
|
}
|
|
|
|
// Walk the advise list looking for the connection
|
|
// Make sure we're safe to monkey with the list
|
|
if (hResult = HrWaitForObject(hmtxAdviseList, ADVISE_TIMEOUT)) {
|
|
DebugTrace("HrUnadvise:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fMutex = TRUE;
|
|
|
|
lpAdviseNode = AdviseList.lpNode;
|
|
|
|
while (lpAdviseNode) {
|
|
if (lpAdviseNode->ulConnection == ulConnection) {
|
|
// Found it, remove from list
|
|
*lppPrevNode = lpAdviseNode->lpNext;
|
|
|
|
// BUGBUG: Don't forget to remove any notifications that haven't been
|
|
// processed by this process yet.
|
|
|
|
// Free the node
|
|
LocalFreeAndNull(&lpAdviseNode);
|
|
goto exit;
|
|
}
|
|
lppPrevNode = &(lpAdviseNode->lpNext);
|
|
lpAdviseNode = lpAdviseNode->lpNext;
|
|
}
|
|
|
|
hResult = ResultFromScode(MAPI_E_NOT_FOUND);
|
|
|
|
exit:
|
|
if (fMutex) {
|
|
ReleaseMutex(hmtxAdviseList);
|
|
}
|
|
#else
|
|
hResult = ResultFromScode(MAPI_E_CALL_FAILED);
|
|
#endif
|
|
|
|
return(hResult);
|
|
*/
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Name : HrFireNotification
|
|
|
|
Purpose : Fire a notification
|
|
|
|
Parameters: lpNotification -> NOTIFICATION structure
|
|
|
|
Returns : HRESULT
|
|
|
|
Comment : What happens in here:
|
|
if shared memory exists
|
|
Map in the shared memory
|
|
Add the notification to the global Advise list
|
|
Set the count on this notification to the global
|
|
advise count.
|
|
trigger the Global Advise Event.
|
|
|
|
***************************************************************************/
|
|
HRESULT HrFireNotification(LPNOTIFICATION lpNotification) {
|
|
HRESULT hResult = hrSuccess;
|
|
#ifdef NEW_STUFF
|
|
LPNOTIFICATION_LIST lpNotifyList = NULL;
|
|
HANDLE hmemNotifyList = NULL;
|
|
HANDLE hmtxNotifyList = NULL;
|
|
HANDLE hevNotifyList = NULL;
|
|
LPNOTIFICATION_NODE lpNewNode = NULL, lpTempNode, *lppPrevNode;
|
|
BOOL fNotifyMutex = FALSE, fAdviseMutex = FALSE;
|
|
BOOL fOpened = FALSE;
|
|
|
|
Assert(lpNotification);
|
|
|
|
// If there is an Advise session, use it, else create a temporary
|
|
// Notification session
|
|
if (lpNotificationList) {
|
|
lpNotifyList = lpNotificationList;
|
|
hmtxNotifyList = hmtxNotificationList;
|
|
hevNotifyList = hevNotificationList;
|
|
} else {
|
|
if (hResult = OpenNotifySession(&lpNotifyList,
|
|
&hmemNotifyList,
|
|
&hmtxNotifyList,
|
|
&hevNotifyList)) {
|
|
DebugTraceResult( TEXT("HrAdvise:OpenNotifySession"), hResult);
|
|
// No waiting advise sessions, there's no point in continuing
|
|
goto exit;
|
|
}
|
|
fOpened = TRUE;
|
|
}
|
|
|
|
|
|
// Request access to the Global Notification List
|
|
if (hResult = HrWaitForObject(hmtxNotifyList, FIRE_NOTIFY_TIMEOUT)) {
|
|
DebugTrace("HrFireNotification:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fNotifyMutex = TRUE;
|
|
|
|
// Add the notification to the beginning of the global notification list
|
|
// create a new node for it
|
|
|
|
if (! (lpNewNode = LocalAlloc(LPTR, sizeof(NOTIFICATION_NODE)))) {
|
|
DebugTrace("LocalAlloc(%u) NotificationNode -> %u\n", sizeof(NOTIFICATION_NODE), GetLastError());
|
|
hResult = ResultFromScode(MAPI_E_NOT_ENOUGH_MEMORY);
|
|
goto exit;
|
|
}
|
|
|
|
|
|
lpNewNode->cbSize = sizeof(NOTIFICATION_NODE);
|
|
|
|
// BUGBUG: This doesn't copy the stuff pointed to in the notification structure!
|
|
CopyMemory(&lpNewNode->Notification, lpNotification, sizeof(NOTIFICATION));
|
|
|
|
// Add the new node to END of the list. Note that it must go to the end
|
|
// of the list so that the unique identifiers are kept in order.
|
|
|
|
// Make sure we're safe to monkey with the Advise list
|
|
if (hResult = HrWaitForObject(hmtxAdviseList, ADVISE_TIMEOUT)) {
|
|
DebugTrace("HrAdvise:Mutex wait failed\n");
|
|
goto exit;
|
|
}
|
|
fAdviseMutex = TRUE;
|
|
|
|
lpNewNode->lpNext = NULL;
|
|
|
|
lpTempNode = lpNotifyList->lpNode;
|
|
lppPrevNode = &lpNotifyList->lpNode;
|
|
while (lpTempNode) {
|
|
lppPrevNode = &lpTempNode->lpNext;
|
|
lpTempNode = lpTempNode->lpNext;
|
|
}
|
|
*lppPrevNode = lpNewNode;
|
|
|
|
// Set the count on this notification to the global
|
|
// advise count.
|
|
lpNewNode->ulCount = lpNotificationList->cAdvises;
|
|
|
|
// Set the unique identifier for this notification
|
|
lpNewNode->ulIdentifier = lpNotifyList->ulNextIdentifier++;
|
|
|
|
// trigger the Global Advise Event.
|
|
if (! PulseEvent(hevNotifyList)) {
|
|
DebugTrace("HrFireNotification:PulseEvent -> %u\n", GetLastError());
|
|
// what are ya gonna do?
|
|
hResult = ResultFromScode(MAPI_E_CALL_FAILED);
|
|
goto exit;
|
|
}
|
|
|
|
|
|
exit:
|
|
if (fNotifyMutex) {
|
|
ReleaseMutex(hmtxNotifyList);
|
|
}
|
|
if (fAdviseMutex) {
|
|
ReleaseMutex(hmtxAdviseList);
|
|
}
|
|
|
|
// Clean up the stuff if we opened it.
|
|
if (fOpened) {
|
|
if (lpNotifyList) {
|
|
UnmapViewOfFile(lpNotifyList);
|
|
}
|
|
if (hmemNotifyList) {
|
|
CloseHandle(hmemNotifyList);
|
|
}
|
|
if (hmtxNotifyList) {
|
|
CloseHandle(hmtxNotifyList);
|
|
}
|
|
if (hevNotifyList) {
|
|
CloseHandle(hevNotifyList);
|
|
}
|
|
}
|
|
|
|
#else
|
|
hResult = ResultFromScode(MAPI_E_CALL_FAILED);
|
|
#endif
|
|
return(hResult);
|
|
}
|
|
|
|
#ifdef NEW_STUFF
|
|
/***************************************************************************
|
|
|
|
Name : AdviseThread
|
|
|
|
Purpose : Thread routine for advise
|
|
|
|
Parameters: lpdwParam = Thread parameter
|
|
|
|
Returns : DWORD return code.
|
|
|
|
Comment : What happens in here:
|
|
loop until Unadvise
|
|
wait for trigger of the Global Advise Event or Unadvise event
|
|
if Advise Event
|
|
Loop through global advise list
|
|
if we haven't already dealt with this notification
|
|
check events in global advise list against local advise list
|
|
if match
|
|
call client's NotifCallback
|
|
Decrement count in this notification
|
|
if count == 0
|
|
remove this item from the global advise list
|
|
|
|
if Unadvise
|
|
decrement global advise count
|
|
exit thread
|
|
|
|
***************************************************************************/
|
|
DWORD AdviseThread(LPDWORD lpdwParam) {
|
|
BOOL fNotifyMutex = FALSE, fAdviseMutex = FALSE;
|
|
LPNOTIFICATION_NODE lpNotifyNode = NULL, *lppNotifyPrev;
|
|
LPADVISE_NODE lpAdviseNode = NULL;
|
|
|
|
// loop until Unadvise
|
|
while (TRUE) {
|
|
// wait for trigger of the Global Advise Event or Unadvise event
|
|
switch(WaitForTwoObjects(hevNotificationList, hevKillAdvise, ADVISE_THREAD_TIMEOUT)) {
|
|
case 0:
|
|
// New notification
|
|
break;
|
|
case (ULONG)-1:
|
|
// error
|
|
DebugTrace("AdviseThread:WaitForTwoObjects error\n");
|
|
// fall through to kill
|
|
case 1:
|
|
// kill advise
|
|
DebugTrace("Terminating AdviseThread\n");
|
|
goto exit;
|
|
}
|
|
|
|
// New notification
|
|
// Loop through global notification list
|
|
// Gain access to list
|
|
// wait for trigger of the Global Advise Event or Unadvise event
|
|
switch(WaitForTwoObjects(hmtxNotificationList, hevKillAdvise, NOTIFY_ADVISE_TIMEOUT)) {
|
|
case 0:
|
|
// Got the List Mutex
|
|
fNotifyMutex = TRUE;
|
|
break;
|
|
case (ULONG)-1:
|
|
// error
|
|
DebugTrace("AdviseThread:WaitForTwoObjects error\n");
|
|
// fall through to kill
|
|
case 1:
|
|
// kill advise
|
|
DebugTrace("Terminating AdviseThread\n");
|
|
goto exit;
|
|
}
|
|
Assert(fNotifyMutex);
|
|
|
|
// Also need to look at the local advise list
|
|
switch(WaitForTwoObjects(hmtxAdviseList, hevKillAdvise, NOTIFY_ADVISE_TIMEOUT)) {
|
|
case 0:
|
|
// Got the List Mutex
|
|
fAdviseMutex = TRUE;
|
|
break;
|
|
case (ULONG)-1:
|
|
// error
|
|
DebugTrace("AdviseThread:WaitForTwoObjects error\n");
|
|
// fall through to kill
|
|
case 1:
|
|
// kill advise
|
|
DebugTrace("Terminating AdviseThread\n");
|
|
goto exit;
|
|
}
|
|
Assert(fAdviseMutex);
|
|
|
|
lpNotifyNode = lpNotificationList->lpNode;
|
|
lppNotifyPrev = &(lpNotificationList->lpNode);
|
|
|
|
while (lpNotifyNode) {
|
|
// if we haven't already dealt with this notification
|
|
if (lpNotifyNode->ulIdentifier > ulMaxIdentifierSeen) {
|
|
// We haven't seen this one yet. Process it.
|
|
// NOTE: For this to work, new notification nodes must be added
|
|
// at the END of the notification list!
|
|
ulMaxIdentifierSeen = lpNotifyNode->ulIdentifier;
|
|
|
|
// check this notification event against local advise list
|
|
lpAdviseNode = AdviseList.lpNode;
|
|
while (lpAdviseNode) {
|
|
if (lpNotifyNode->Notification.ulEventType & lpAdviseNode->ulEventMask) {
|
|
// Right event type, is it the right object?
|
|
switch (lpNotifyNode->Notification.ulEventType) {
|
|
case fnevCriticalError:
|
|
// ERROR_NOTIFICATION
|
|
if (CompareEntryIDs(lpAdviseNode->cbEntryID,
|
|
(LPENTRYID)&lpAdviseNode->EntryID,
|
|
lpNotifyNode->Notification.info.err.cbEntryID,
|
|
lpNotifyNode->Notification.info.err.lpEntryID)) {
|
|
// This is it!
|
|
// Call the notification callback
|
|
lpAdviseNode->lpAdviseSink->lpVtbl->OnNotify(lpAdviseNode->lpAdviseSink,
|
|
1,
|
|
&lpNotifyNode->Notification);
|
|
}
|
|
break;
|
|
case fnevObjectCreated:
|
|
case fnevObjectDeleted:
|
|
case fnevObjectModified:
|
|
case fnevObjectCopied:
|
|
case fnevObjectMoved:
|
|
case fnevSearchComplete:
|
|
// OBJECT_NOTIFICATION
|
|
if (CompareEntryIDs(lpAdviseNode->cbEntryID,
|
|
(LPENTRYID)&lpAdviseNode->EntryID,
|
|
lpNotifyNode->Notification.info.obj.cbEntryID,
|
|
lpNotifyNode->Notification.info.obj.lpEntryID)) {
|
|
// This is it!
|
|
// Call the notification callback
|
|
lpAdviseNode->lpAdviseSink->lpVtbl->OnNotify(lpAdviseNode->lpAdviseSink,
|
|
1,
|
|
&lpNotifyNode->Notification);
|
|
}
|
|
break;
|
|
|
|
case fnevTableModified:
|
|
// TABLE_NOTIFICATION
|
|
// BUGBUG: NYI
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
lpAdviseNode = lpAdviseNode->lpNext;
|
|
}
|
|
|
|
// Decrement count in this notification
|
|
// if count == 0
|
|
// remove this item from the global notification list
|
|
if (--lpNotifyNode->ulCount == 0) {
|
|
*lppNotifyPrev = lpNotifyNode->lpNext;
|
|
LocalFree(lpNotifyNode);
|
|
lpNotifyNode = *lppNotifyPrev;
|
|
} else {
|
|
lpNotifyNode = lpNotifyNode->lpNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fNotifyMutex) {
|
|
fNotifyMutex = FALSE;
|
|
ReleaseMutex(hmtxNotificationList);
|
|
}
|
|
if (fAdviseMutex) {
|
|
fAdviseMutex = FALSE;
|
|
ReleaseMutex(hmtxAdviseList);
|
|
}
|
|
}
|
|
|
|
exit:
|
|
// exit thread
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
#endif
|