ws2help.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_WSH_HANDLE
struct	_WSH_HASH_TABLE
struct	_WSH_SEARCH_TABLE
struct	_WSH_HANDLE_TABLE

Typedefs
typedef struct _WSH_HANDLE	WSH_HANDLE
typedef struct _WSH_HANDLE *	PWAH_HANDLE
typedef struct _WSH_HASH_TABLE	WSH_HASH_TABLE
typedef struct _WSH_HASH_TABLE *	PWAH_HASH_TABLE
typedef struct _WSH_SEARCH_TABLE	WSH_SEARCH_TABLE
typedef struct _WSH_SEARCH_TABLE *	PWAH_SEARCH_TABLE
typedef struct _WSH_HANDLE_TABLE	WSH_HANDLE_TABLE
typedef struct _WSH_HANDLE_TABLE *	PWAH_HANDLE_TABLE
typedef BOOL(WINAPI *	PWAH_HANDLE_ENUMERATE_PROC) (IN PVOID Context, IN PWAH_HANDLE Handle)

Functions
PWAH_HANDLE WINAPI	WahReferenceContextByHandle (IN PWAH_HANDLE_TABLE Table, IN HANDLE Handle)
DWORD WINAPI	WahRemoveHandleContext (IN PWAH_HANDLE_TABLE Table, IN PWAH_HANDLE Handle)
DWORD WINAPI	WahCloseSocketHandle (IN HANDLE HelperHandle, IN SOCKET Socket)
DWORD WINAPI	WahOpenCurrentThread (IN HANDLE HelperHandle, OUT LPWSATHREADID ThreadId)
DWORD WINAPI	WahCloseApcHelper (IN HANDLE HelperHandle)
DWORD WINAPI	WahCloseThread (IN HANDLE HelperHandle, IN LPWSATHREADID ThreadId)
DWORD WINAPI	WahCloseHandleHelper (IN HANDLE HelperHandle)
DWORD WINAPI	WahCloseNotificationHandleHelper (IN HANDLE HelperHandle)
DWORD WINAPI	WahOpenNotificationHandleHelper (OUT PHANDLE HelperHandle)
DWORD WINAPI	WahCreateNotificationHandle (IN HANDLE HelperHandle, OUT PHANDLE NotificationHelperHandle)
INT WINAPI	WahWaitForNotification (IN HANDLE NotificationHelperHandle, IN HANDLE lpNotificationHandle, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
INT WINAPI	WahNotifyAllProcesses (IN HANDLE NotificationHelperHandle)
BOOL WINAPI	WahEnumerateHandleContexts (IN PWAH_HANDLE_TABLE Table, IN PWAH_HANDLE_ENUMERATE_PROC Callback, IN PVOID Context)
DWORD WINAPI	WahCreateHandleContextTable (OUT PWAH_HANDLE_TABLE *Table)
DWORD WINAPI	WahDestroyHandleContextTable (IN PWAH_HANDLE_TABLE Table)
PWAH_HANDLE WINAPI	WahInsertHandleContext (IN PWAH_HANDLE_TABLE Table, IN PWAH_HANDLE Handle)
DWORD WINAPI	WahOpenApcHelper (OUT PHANDLE ApcHelperHandle)

Typedef Documentation

PWAH_HANDLE

typedef struct _WSH_HANDLE * PWAH_HANDLE

PWAH_HANDLE_ENUMERATE_PROC

typedef BOOL(WINAPI * PWAH_HANDLE_ENUMERATE_PROC) (IN PVOID Context, IN PWAH_HANDLE Handle)

Definition at line 43 of file ws2help.h.

PWAH_HANDLE_TABLE

typedef struct _WSH_HANDLE_TABLE * PWAH_HANDLE_TABLE

PWAH_HASH_TABLE

typedef struct _WSH_HASH_TABLE * PWAH_HASH_TABLE

PWAH_SEARCH_TABLE

typedef struct _WSH_SEARCH_TABLE * PWAH_SEARCH_TABLE

WSH_HANDLE

typedef struct _WSH_HANDLE WSH_HANDLE

WSH_HANDLE_TABLE

typedef struct _WSH_HANDLE_TABLE WSH_HANDLE_TABLE

WSH_HASH_TABLE

typedef struct _WSH_HASH_TABLE WSH_HASH_TABLE

WSH_SEARCH_TABLE

typedef struct _WSH_SEARCH_TABLE WSH_SEARCH_TABLE

Function Documentation

WahCloseApcHelper()

DWORD WINAPI WahCloseApcHelper

(

IN HANDLE

HelperHandle

)

Definition at line 42 of file apc.c.

{
    DWORD ErrorCode;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate handle */
    if (ApcHelperHandle != APCH) return ERROR_INVALID_PARAMETER;
 
    /* return */
    return ERROR_SUCCESS;
}

Referenced by WsProcDelete().

WahCloseHandleHelper()

DWORD WINAPI WahCloseHandleHelper

(

IN HANDLE

HelperHandle

)

Definition at line 86 of file handle.c.

{
    DWORD ErrorCode;
    PWAH_HELPER_CONTEXT Context = HelperHandle;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate the handle */
    if (!Context) return ERROR_INVALID_PARAMETER;
 
    /* Queue an APC to exit the thread */
    if (QueueUserAPC(ExitThreadApc, Context->ThreadHandle, (ULONG_PTR)Context))
    {
        /* Done */
        return ERROR_SUCCESS;
    }
    else
    {
        /* We failed somewhere */
        return ERROR_GEN_FAILURE;
    }
}

Referenced by WsProcDelete().

WahCloseNotificationHandleHelper()

DWORD WINAPI WahCloseNotificationHandleHelper

(

IN HANDLE

HelperHandle

)

Definition at line 22 of file notify.c.

{
    DWORD ErrorCode;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate handle */
    if (HelperHandle != HANH) return ERROR_INVALID_PARAMETER;
 
    /* return */
    return ERROR_SUCCESS;
}

Referenced by WsProcDelete().

WahCloseSocketHandle()

DWORD WINAPI WahCloseSocketHandle	(	IN HANDLE	HelperHandle,
		IN SOCKET	Socket
	)

Definition at line 113 of file handle.c.

{
    DWORD ErrorCode;
    PWAH_HELPER_CONTEXT Context = HelperHandle;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate the handle */
    if (!(Context) || (Socket == INVALID_SOCKET) || !(Socket))
    {
        /* Invalid handle and/or socket */
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Just close the handle and return */
    CloseHandle((HANDLE)Socket);
    return ERROR_SUCCESS;
}

Referenced by WsProcDetachSocket().

WahCloseThread()

DWORD WINAPI WahCloseThread	(	IN HANDLE	HelperHandle,
		IN LPWSATHREADID	ThreadId
	)

Definition at line 59 of file apc.c.

{
    DWORD ErrorCode;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate handles */
    if ((ApcHelperHandle != APCH) || (!ThreadId) || (!ThreadId->ThreadHandle))
    {
        /* Invalid helper/thread handles */
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Close the thread handle */
    if (CloseHandle(ThreadId->ThreadHandle))
    {
        /* Clear the structure */
        ThreadId->ThreadHandle = NULL;
        ThreadId->Reserved = 0;
        return NO_ERROR;
    }
 
    /* return */
    return GetLastError();
}

Referenced by WsThreadDelete().

WahCreateHandleContextTable()

DWORD WINAPI WahCreateHandleContextTable

(

OUT PWAH_HANDLE_TABLE *

Table

)

Definition at line 189 of file context.c.

{
    DWORD ErrorCode;
    PWAH_HANDLE_TABLE LocalTable;
    DWORD i;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Assume NULL */
    *Table = NULL;
 
    /* Allocate enough tables */
    LocalTable = HeapAlloc(GlobalHeap,
                           0,
                           FIELD_OFFSET(WSH_HANDLE_TABLE,
                                        SearchTables[gHandleToIndexMask + 1]));
 
    /* Make sure it was allocated */
    if (!LocalTable) return WSA_NOT_ENOUGH_MEMORY;
 
    /* Set the mask for the table */
    LocalTable->Mask = gHandleToIndexMask;
 
    /* Now initialize every table */
    for (i = 0; i <= gHandleToIndexMask; i++)
    {
        /* No hash table yet */
        LocalTable->SearchTables[i].HashTable = NULL;
 
        /* Set the current count */
        LocalTable->SearchTables[i].CurrentCount = &LocalTable->SearchTables[i].Count1;
 
        /* Initialize the counts */
        LocalTable->SearchTables[i].Count1 = 1;
        LocalTable->SearchTables[i].Count2 = 0;
 
        /* Set expanding state and spin count */
        LocalTable->SearchTables[i].Expanding = FALSE;
        LocalTable->SearchTables[i].SpinCount = gdwSpinCount;
 
        /* Initialize the lock */
        (VOID)InitializeCriticalSectionAndSpinCount(&LocalTable->
                                                    SearchTables[i].Lock,
                                                    gdwSpinCount);
    }
 
    /* Return pointer */
    *Table = LocalTable;
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by WsSockStartup().

WahCreateNotificationHandle()

DWORD WINAPI WahCreateNotificationHandle	(	IN HANDLE	HelperHandle,
		OUT PHANDLE	NotificationHelperHandle
	)

Definition at line 39 of file notify.c.

{
    UNREFERENCED_PARAMETER(HelperHandle);
    UNREFERENCED_PARAMETER(NotificationHelperHandle);
    return 0;
}

WahDestroyHandleContextTable()

DWORD WINAPI WahDestroyHandleContextTable

(

IN PWAH_HANDLE_TABLE

Table

)

Definition at line 246 of file context.c.

{
    DWORD i;
 
    /* Make sure the table is valid */
    if (!Table)
    {
        /* No valid table */
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Loop each search table */
    for (i = 0; i <= Table->Mask; i++)
    {
        /* Check if there's a table here */
        if (Table->SearchTables[i].HashTable)
        {
            /* Free it */
            HeapFree(GlobalHeap, 0, Table->SearchTables[i].HashTable);
        }
 
        /* Delete the lock */
        DeleteCriticalSection(&Table->SearchTables[i].Lock);
    }
 
    /* Delete the table */
    HeapFree(GlobalHeap, 0, Table);
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by WsSockCleanup().

WahEnumerateHandleContexts()

BOOL WINAPI WahEnumerateHandleContexts	(	IN PWAH_HANDLE_TABLE	Table,
		IN PWAH_HANDLE_ENUMERATE_PROC	Callback,
		IN PVOID	Context
	)

Definition at line 280 of file context.c.

{
    DWORD i, j;
    PWAH_SEARCH_TABLE SearchTable;
    PWAH_HASH_TABLE HashTable;
    PWAH_HANDLE Handle;
    BOOL GoOn = TRUE;
 
    /* Loop the table */
    for (i = 0; i <= Table->Mask; i++)
    {
        /* Get the Search table */
        SearchTable = &Table->SearchTables[i];
 
        /* Lock it */
        AcquireWriteLock(SearchTable);
 
        /* Mark us as expanding and wait for everyone */
        SearchTable->Expanding = TRUE;
        TryWaitForReaders(SearchTable);
 
        /* Get the hash table */
        HashTable = SearchTable->HashTable;
 
        /* Make sure it exists */
        if (HashTable)
        {
            /* Loop every handle in it */
            for (j = 0; j < HashTable->Size; j++)
            {
                /* Get this handle */
                Handle = HashTable->Handles[j];
                if (!Handle) continue;
 
                /* Call the callback proc */
                GoOn = Callback(Context, Handle);
                if (!GoOn) break;
            }
        }
 
        /* Disable the expansion bit and release the lock */
        SearchTable->Expanding = FALSE;
        ReleaseWriteLock(SearchTable);
 
        /* Check again if we should leave */
        if (!GoOn) break;
    }
 
    /* return */
    return GoOn;
}

Referenced by WsProcDelete().

WahInsertHandleContext()

PWAH_HANDLE WINAPI WahInsertHandleContext	(	IN PWAH_HANDLE_TABLE	Table,
		IN PWAH_HANDLE	Handle
	)

Definition at line 336 of file context.c.

{
    PWAH_HANDLE *HashHandle, OldHandle;
    PVLONG Count;
    PWAH_HASH_TABLE HashTable, NewHashTable;
    DWORD HandleCount, i;
    PWAH_SEARCH_TABLE SearchTable;
 
    /* Get the current Search Table */
    SearchTable = WSH_SEARCH_TABLE_FROM_HANDLE(Handle->Handle, Table);
 
    /* Start loop */
    do
    {
        /* Get reader lock */
        AcquireReadLock(SearchTable, &Count);
 
        /* Get the hash table */
        HashTable = SearchTable->HashTable;
 
        /* Make sure we are not expanding, and that the table is there */
        if (!(SearchTable->Expanding) && (HashTable))
        {
            /* Get the hash handle */
            HashHandle = &WSH_HASH_FROM_HANDLE(Handle->Handle, HashTable);
 
            /* Do the insert */
            if (InterlockedCompareExchangePointer((PVOID*)HashHandle,
                                                  Handle,
                                                  NULL) == NULL)
            {
                /* Success, release the reader lock */
                ReleaseReadLock(SearchTable, Count);
 
                /* Save old handle */
                OldHandle = Handle;
                break;
            }
        }
 
        /* Release the read lock since we're done with it now */
        ReleaseReadLock(SearchTable, Count);
 
        /* We need the writer lock to expand/create the table */
        AcquireWriteLock(SearchTable);
 
        /* Mark the table in use */
        SearchTable->Expanding = TRUE;
 
        /* Wait for all the readers to finish */
        TryWaitForReaders(SearchTable);
 
        /* Start loop */
        do
        {
            /* Get the hash table again */
            HashTable = SearchTable->HashTable;
 
            /* Check if exists now */
            if (HashTable)
            {
                /* It does! Do what we wanted to do earlier. Get the hash... */
                HashHandle = &WSH_HASH_FROM_HANDLE(Handle->Handle, HashTable);
 
                /* Check if it doesn't exist */
                if (!(*HashHandle))
                {
                    /* Write it (no need for interlock, we have the RW lock) */
                    OldHandle = Handle;
                    *HashHandle = Handle;
                    break;
                }
                else if ((*HashHandle)->Handle == Handle->Handle)
                {
                    /* Handle matches, write it (see comment above) */
                    OldHandle = *HashHandle;
                    *HashHandle = Handle;
                    break;
                }
 
                /* No go, we need to expand the table. Remember the size now */
                HandleCount = HashTable->Size;
            }
            else
            {
                /* Table is empty, we have to create it */
                HandleCount = 0;
            }
 
ExpandTable:
            /* Find a free prime */
            for (i = 0; HandleCount >= SockPrimes[i]; i++);
 
            /* Check if we found one */
            if (SockPrimes[i] != 0xFFFFFFFF)
            {
                /* Use the prime */
                HandleCount = SockPrimes[i];
            }
            else
            {
                /* No primes left. Table is quite large, so simply double it */
                HandleCount *= 2;
            }
 
            /* Allocate the table */
            NewHashTable = HeapAlloc(GlobalHeap,
                                     0,
                                     FIELD_OFFSET(WSH_HASH_TABLE,
                                                  Handles[HandleCount]));
 
            /* Hopefully we have one now */
            if (NewHashTable)
            {
                /* Set its size */
                NewHashTable->Size = HandleCount;
 
                /* Initialize it */
                RtlZeroMemory(NewHashTable->Handles, HandleCount * sizeof(PVOID));
 
                /* Insert us first */
                WSH_HASH_FROM_HANDLE(Handle->Handle, NewHashTable) = Handle;
 
                /* Now check if our old table had entries in it */
                if (HashTable)
                {
                    /* We need to move them */
                    for (i = 0; i < HashTable->Size; i++)
                    {
                        /* Make sure the hash handle exists */
                        if (HashTable->Handles[i])
                        {
                            /* Get it */
                            HashHandle = &WSH_HASH_FROM_HANDLE(HashTable->
                                                               Handles[i]->Handle,
                                                               NewHashTable);
 
                            /* Check if it has a value */
                            if (!(*HashHandle))
                            {
                                /* It's empty, so just write the handle */
                                *HashHandle = HashTable->Handles[i];
                            }
                            else
                            {
                                /* Not empty :/... that implies a collision */
                                HeapFree(GlobalHeap, 0, NewHashTable);
                                goto ExpandTable;
                            }
                        }
                    }
 
                    /* Write the new hash table */
                    SearchTable->HashTable = NewHashTable;
 
                    /* Wait for everyone to be done with it, then free it */
                    TryWaitForReaders(SearchTable);
                    HeapFree(GlobalHeap, 0, HashTable);
                }
                else
                {
                    /* It was empty, nothing to worry about */
                    SearchTable->HashTable = NewHashTable;
                }
 
                /* Save the old handle */
                OldHandle = Handle;
            }
            else
            {
                /* There was no old handle */
                OldHandle = Handle;
            }
        } while (0);
 
        /* Mark us as free, and release the write lock */
        SearchTable->Expanding = FALSE;
        ReleaseWriteLock(SearchTable);
        break;
    } while (1);
 
    /* Return the old handle */
    return OldHandle;
}

Referenced by WsSockAssociateHandle().

WahNotifyAllProcesses()

INT WINAPI WahNotifyAllProcesses

(

IN HANDLE

NotificationHelperHandle

)

Definition at line 67 of file notify.c.

{
    UNREFERENCED_PARAMETER(NotificationHelperHandle);
    return 0;
}

WahOpenApcHelper()

DWORD WINAPI WahOpenApcHelper

(

OUT PHANDLE

ApcHelperHandle

)

Definition at line 20 of file apc.c.

{
    DWORD ErrorCode;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate handle */
    if (!ApcHelperHandle) return ERROR_INVALID_PARAMETER;
 
    /*
     * Return a bogus handle ("ROS")
     * Historical note:(MS sends "CKM", which probably stands for "Keith Moore"
     * (KM), one of the core architects of Winsock 2.2 from Microsoft.
     */
    *ApcHelperHandle = APCH;
    return ERROR_SUCCESS;
}

Referenced by WsProcOpenAsyncHelperDevice().

WahOpenCurrentThread()

DWORD WINAPI WahOpenCurrentThread	(	IN HANDLE	HelperHandle,
		OUT LPWSATHREADID	ThreadId
	)

Definition at line 118 of file apc.c.

{
    HANDLE ProcessHandle, ThreadHandle;
 
    /* Validate params  */
    if ((ApcHelperHandle != APCH) || (!ThreadId))
    {
        /* Invalid parameters */
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Get the process/thread handles */
    ProcessHandle = GetCurrentProcess();
    ThreadHandle = GetCurrentThread();
 
    /* Duplicate the handle */
    if (DuplicateHandle(ProcessHandle,
                        ThreadHandle,
                        ProcessHandle,
                        &ThreadId->ThreadHandle,
                        0,
                        FALSE,
                        DUPLICATE_SAME_ACCESS))
    {
        /* Save the thread handle and return */
        ThreadId->Reserved = (DWORD_PTR)ThreadHandle;
        return ERROR_SUCCESS;
    }
 
    /* Fail */
    return GetLastError();
}

Referenced by WsThreadInitialize().

WahOpenNotificationHandleHelper()

DWORD WINAPI WahOpenNotificationHandleHelper

(

OUT PHANDLE

HelperHandle

)

Definition at line 49 of file notify.c.

{
    DWORD ErrorCode;
 
    /* Enter the prolog, make sure we're initialized */
    ErrorCode = WS2HELP_PROLOG();
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
 
    /* Validate handle */
    if (!HelperHandle) return ERROR_INVALID_PARAMETER;
 
    /* Return a bogus handle ("ROS2") */
    *HelperHandle = HANH;
    return ERROR_SUCCESS;
}

WahReferenceContextByHandle()

PWAH_HANDLE WINAPI WahReferenceContextByHandle	(	IN PWAH_HANDLE_TABLE	Table,
		IN HANDLE	Handle
	)

Definition at line 524 of file context.c.

{
    PWAH_HANDLE HashHandle;
    PWAH_SEARCH_TABLE SearchTable;
    PWAH_HASH_TABLE HashTable;
    PVLONG Count;
 
    /* Get the current Search Table */
    SearchTable = WSH_SEARCH_TABLE_FROM_HANDLE(Handle, Table);
 
    /* Lock it */
    AcquireReadLock(SearchTable, &Count);
 
    /* Get the hash table and handle */
    HashTable = SearchTable->HashTable;
 
    /* Check if it's valid, and if it's the one we want */
    if ((HashTable) &&
        (HashHandle = WSH_HASH_FROM_HANDLE(Handle, HashTable)) &&
        (HashHandle->Handle == Handle))
    {
        /* Reference the handle */
        InterlockedIncrement(&HashHandle->RefCount);
    }
    else
    {
        /* Invalid handle */
        HashHandle = NULL;
    }
 
    /* Release the lock */
    ReleaseReadLock(SearchTable, Count);
 
    /* Return */
    return HashHandle;
}

Referenced by WsSockGetSocket(), and WsSockGetSocketNoExport().

WahRemoveHandleContext()

DWORD WINAPI WahRemoveHandleContext	(	IN PWAH_HANDLE_TABLE	Table,
		IN PWAH_HANDLE	Handle
	)

Definition at line 564 of file context.c.

{
    PWAH_HANDLE *HashHandle;
    PWAH_SEARCH_TABLE SearchTable;
    PWAH_HASH_TABLE HashTable;
    DWORD ErrorCode = ERROR_SUCCESS;
 
    /* Get the current Search Table */
    SearchTable = WSH_SEARCH_TABLE_FROM_HANDLE(Handle->Handle, Table);
 
    /* Lock it */
    AcquireWriteLock(SearchTable);
 
    /* Get the hash table and handle */
    HashTable = SearchTable->HashTable;
    HashHandle = &WSH_HASH_FROM_HANDLE(Handle->Handle, HashTable);
 
    /* Make sure we have a handle, and write the new pointer */
    if (HashHandle && (InterlockedCompareExchangePointer((PVOID*)HashHandle,
                                                         NULL,
                                                         Handle) == Handle))
    {
        /* Wait for everyone to be done with it */
        TryWaitForReaders(SearchTable);
    }
    else
    {
        /* Invalid handle */
        ErrorCode = ERROR_INVALID_PARAMETER;
    }
 
    /* Release the lock */
    ReleaseWriteLock(SearchTable);
 
    /* Return */
    return ErrorCode;
}

Referenced by WsProcDetachSocket(), and WsSockDisassociateHandle().

WahWaitForNotification()

INT WINAPI WahWaitForNotification	(	IN HANDLE	NotificationHelperHandle,
		IN HANDLE	lpNotificationHandle,
		IN LPWSAOVERLAPPED	lpOverlapped,
		IN LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine
	)

Definition at line 75 of file notify.c.

{
    UNREFERENCED_PARAMETER(NotificationHelperHandle);
    UNREFERENCED_PARAMETER(lpNotificationHandle);
    UNREFERENCED_PARAMETER(lpOverlapped);
    UNREFERENCED_PARAMETER(lpCompletionRoutine);
    return 0;
}