windows-xp/Source/XPSP1/NT/net/layer2svc/eapol/service/eldeviceio.c

/*++

Copyright (c) 2000, Microsoft Corporation

Module Name:

    eldeviceio.c

Abstract:

    This module contains implementations for media-management and device I/O.
    The routines declared here operate asynchronously on the handles 
    associated with an I/O completion port opened on the ndis uio driver. 

Revision History:

    sachins, Apr 23 2000, Created

--*/

#include "pcheapol.h"
#pragma hdrstop

// NDISUIO constants

CHAR            NdisuioDevice[] = "\\\\.\\\\Ndisuio";
CHAR *          pNdisuioDevice = &NdisuioDevice[0];
WCHAR           cwszNDISUIOProtocolName[] = L"NDISUIO";
WORD            g_wEtherType8021X= 0x8E88;


//
// ElMediaInit
// 
// Description:
//
// Called on EAPOL service startup to initialize all the media related events 
// and callback functions
// 
//
// Arguments:
//
// Return Values:
//

DWORD
ElMediaInit (
        )
{
    DWORD       dwIndex = 0;
    DWORD       dwRetCode = NO_ERROR;

    TRACE0 (INIT, "ElMediaInit: Entered");

    do 
    {
        // Create Global Interface lock
        if (dwRetCode = CREATE_READ_WRITE_LOCK(&(g_ITFLock), "ITF") != NO_ERROR)
        {
            TRACE1(EAPOL, "ElMediaInit: Error (%ld) in creating g_ITFLock read-write-lock", dwRetCode);
            break;
        }
        // Initialize NLA locks
        if (dwRetCode = CREATE_READ_WRITE_LOCK(&(g_NLALock), "NLA") != NO_ERROR)
        {
            TRACE1(EAPOL, "ElMediaInit: Error (%ld) in creating g_NLALock read-write-lock", dwRetCode);
            break;
        }

        // Initialize EAPOL structures

        if ((dwRetCode = ElInitializeEAPOL()) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElInitializeEAPOL failed with dwRetCode = %d", 
                    dwRetCode );
            break;
        }
        else
        {
            // TRACE0(INIT, "ElMediaInit: ElInitializeEAPOL successful");
            g_dwModulesStarted |= EAPOL_MODULE_STARTED;
        }
    
        // Initialize interface hash bucket table
    
        g_ITFTable.pITFBuckets = (ITF_BUCKET *) MALLOC (INTF_TABLE_BUCKETS * sizeof (ITF_BUCKET));
    
        if (g_ITFTable.pITFBuckets == NULL)
        {
            TRACE0 (DEVICE, "Error in allocation memory for ITF buckets");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }
    
        for (dwIndex=0; dwIndex < INTF_TABLE_BUCKETS; dwIndex++)
        {
            g_ITFTable.pITFBuckets[dwIndex].pItf=NULL;
        }
    
        // Indicate logon/logoff notifications can be accepted
        g_dwModulesStarted |= LOGON_MODULE_STARTED;

        // Check if service was delayed in starting, start user logon

        ElCheckUserLoggedOn ();

        // Check if the user-context process is ready to be notified

        if ((dwRetCode = ElCheckUserModuleReady ()) == ERROR_BAD_IMPERSONATION_LEVEL)
        {
            break;
        }

        // Enumerate all the interfaces and start EAPOL state machine
        // on interfaces which are of LAN type

        if ((dwRetCode = ElEnumAndOpenInterfaces (NULL, NULL, 0, NULL)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElEnumAndOpenInterfaces failed with dwRetCode = %d", 
                    dwRetCode );
                    
            break;
        }
        else
        {
            // TRACE0(INIT, "ElMediaInit: ElEnumAndOpenInterfaces successful");
        }
        
#ifndef ZEROCONFIG_LINKED

        // Register for Media Sense detection of MEDIA_CONNECT and 
        // MEDIA_DISCONNECT of interfaces
    
        if ((dwRetCode = ElMediaSenseRegister (TRUE)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElMediaSenseRegister failed with dwRetCode = %d", 
                    dwRetCode );
            break;
        }
        else
        {
            g_dwModulesStarted |= WMI_MODULE_STARTED;
            // TRACE0(INIT, "ElMediaInit: ElMediaSenseRegister successful");
        }

        // Register for detecting protocol BIND and UNBIND
    
        if ((dwRetCode = ElBindingsNotificationRegister (TRUE)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElBindingsNotificationRegister failed with dwRetCode = %d", 
                    dwRetCode );
            break;
        }
        else
        {
            g_dwModulesStarted |= BINDINGS_MODULE_STARTED;
            // TRACE0(INIT, "ElMediaInit: ElBindingsNotificationRegister successful");
        }

        // Register for device notifications. We are interested in LAN 
        // interfaces coming and going. 

        if ((dwRetCode = ElDeviceNotificationRegister (TRUE)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElDeviceNotificationRegister failed with dwRetCode = %d", 
                    dwRetCode );
            break;
        }
        else
        {
            g_dwModulesStarted |= DEVICE_NOTIF_STARTED;
            // TRACE0(INIT, "ElMediaInit: ElDeviceNotificationRegister successful");
        }

#endif // ZEROCONFIG_LINKED


    } while (FALSE);
        
    if (dwRetCode == NO_ERROR)
    {
        TRACE0(INIT, "ElMediaInit successful");
    }
    else
    {
        TRACE1(INIT, "ElMediaInit failed with error %ld",
                dwRetCode);
    }

    return dwRetCode;
}

    
//
// ElMediaDeInit
// 
// Description:
//
// Called on EAPOL service shutdown to de-initialize all the media 
// related events and callback functions
// 
//
// Arguments:
//
// Return Values:
//

DWORD
ElMediaDeInit (
        )
{
    LONG        lLocalWorkerThreads = 0;
    DWORD       dwIndex = 0;
    EAPOL_ITF   *pITFWalker = NULL, *pITF = NULL;
    DWORD       dwRetCode = NO_ERROR;

    TRACE0 (INIT, "ElMediaDeInit: Entered");
 
    // Indicate logon/logoff notifications will not be accepted anymore
    g_dwModulesStarted &= ~LOGON_MODULE_STARTED;

#ifndef ZEROCONFIG_LINKED

    // DeRegister Media Sense detection of MEDIA_CONNECT and MEDIA_DISCONNECT
    // of interfaces

    if (g_dwModulesStarted & WMI_MODULE_STARTED)
    {
        if ((dwRetCode = ElMediaSenseRegister (FALSE)) != NO_ERROR )
        {
            TRACE1(INIT, "ElMediaDeInit: ElMediaSenseRegister failed with dwRetCode = %d", 
                    dwRetCode );
            // log
        }
        else
        {
            // TRACE0(INIT, "ElMediaDeInit: ElMediaSenseRegister successful");
        }
            
        g_dwModulesStarted &= ~WMI_MODULE_STARTED;
    }

    // Deregister detecting protocol BIND and UNBIND

    if (g_dwModulesStarted & BINDINGS_MODULE_STARTED)
    {
    
        if ((dwRetCode = ElBindingsNotificationRegister (FALSE)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaDeInit: ElBindingsNotificationRegister failed with dwRetCode = %d", 
                    dwRetCode );
            // log
        }
        else
        {
            g_dwModulesStarted &= ~BINDINGS_MODULE_STARTED;
            // TRACE0(INIT, "ElMediaDeInit: ElBindingsNotificationRegister successful");
        }
    }

    // Deregister device notifications that may have been posted

    if (g_dwModulesStarted & DEVICE_NOTIF_STARTED)
    {
        if ((dwRetCode = ElDeviceNotificationRegister (FALSE)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaDeInit: ElDeviceNotificationRegister failed with dwRetCode = %d", 
                    dwRetCode );
            // log
        }
        else
        {
            // TRACE0(INIT, "ElMediaDeInit: ElDeviceNotificationRegister successful");
        }

        g_dwModulesStarted &= ~DEVICE_NOTIF_STARTED;
    }

#endif // ZEROCONFIG_LINKED

    // Wait for all the related threads to die
    // viz. MediaSense, BindingsNotification, DeviceNotification,
    // Registry-watch for EAP-configuration change,
    // Registry-watch for EAPOL-parameter change

    do
    {
        lLocalWorkerThreads = 0;

        lLocalWorkerThreads = InterlockedCompareExchange (
                                    &g_lWorkerThreads,
                                    0,
                                    0);
        if (lLocalWorkerThreads == 0)
        {
            TRACE0 (INIT, "ElMediaDeInit: No worker threads alive, exiting");
            TRACE2 (INIT, "ElMediaDeInit: (%ld) - (%ld) worker threads still alive", 
                lLocalWorkerThreads, g_lWorkerThreads);
            break;
        }
        TRACE2 (INIT, "ElMediaDeInit: (%ld) - (%ld) worker threads still alive, sleeping zzz... ", 
                lLocalWorkerThreads, g_lWorkerThreads);
        Sleep (1000);
    }
    while (TRUE);

    // Shutdown EAPOL state machine
            
    if (g_dwModulesStarted & EAPOL_MODULE_STARTED)
    {
        if ((dwRetCode = ElEAPOLDeInit()) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaDeInit: ElEAPOLDeInit failed with dwRetCode = %d", 
                    dwRetCode );
            // log
        }
        else
        {
            TRACE0(INIT, "ElMediaDeInit: ElEAPOLDeInit successful");
        }

        g_dwModulesStarted &= ~EAPOL_MODULE_STARTED;
    }


    // Free the interface table

    if (READ_WRITE_LOCK_CREATED(&(g_ITFLock)))
    {
        ACQUIRE_WRITE_LOCK (&(g_ITFLock));

        if (g_ITFTable.pITFBuckets != NULL)
        {

            for (dwIndex = 0; dwIndex < INTF_TABLE_BUCKETS; dwIndex++)
            {
                for (pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
                    pITFWalker != NULL;
                    /* NOTHING */
                    )
                {
                    pITF = pITFWalker;
                    pITFWalker = pITFWalker->pNext;
    
                    if (pITF->pwszInterfaceDesc)
                    {
                        FREE (pITF->pwszInterfaceDesc);
                    }
                    if (pITF->pwszInterfaceGUID)
                    {
                        FREE (pITF->pwszInterfaceGUID);
                    }
                    if (pITF)
                    {
                        FREE (pITF);
                    }
                }
            }

            FREE(g_ITFTable.pITFBuckets);
        }

        ZeroMemory (&g_ITFTable, sizeof (g_ITFTable));

        RELEASE_WRITE_LOCK (&(g_ITFLock));
    
        // Delete ITF table lock

        DELETE_READ_WRITE_LOCK(&(g_ITFLock));

    }
    
    if (READ_WRITE_LOCK_CREATED(&(g_NLALock)))
    {
        // Delete NLA lock

        DELETE_READ_WRITE_LOCK(&(g_NLALock));
    }

    TRACE0(INIT, "ElMediaDeInit completed");

    return dwRetCode;
}

#ifdef  ZEROCONFIG_LINKED

//
// ElMediaEventsHandler
//
// Description:
//
// Function called by WZC Service to signal various media events
//
// Arguments: 
//      pwzcDeviceNotif - Pointer to WZC_DEVICE_NOTIF structure
// 
// Return values:
//      NO_ERROR  - Successful
//      non-zero  - Error
//

DWORD
ElMediaEventsHandler (
        IN  PWZC_DEVICE_NOTIF   pwzcDeviceNotif
        )
{
    DWORD   dwDummyValue = NO_ERROR;
    DWORD   dwRetCode = NO_ERROR;

    do
    {
        TRACE0 (DEVICE, "ElMediaEventsHandler entered");

        if (pwzcDeviceNotif == NULL)
        {
            break;
        }

        switch (pwzcDeviceNotif->dwEventType)
        {
            case WZCNOTIF_DEVICE_ARRIVAL:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElDeviceNotificationHandler ");
                ElDeviceNotificationHandler (
                        (VOID *)&(pwzcDeviceNotif->dbDeviceIntf),
                        DBT_DEVICEARRIVAL
                        );
                break;

            case WZCNOTIF_DEVICE_REMOVAL:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElDeviceNotificationHandler ");
                ElDeviceNotificationHandler (
                        (VOID *)&(pwzcDeviceNotif->dbDeviceIntf),
                        DBT_DEVICEREMOVECOMPLETE
                        );
                break;

            case WZCNOTIF_ADAPTER_BIND:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElBindingsNotificationCallback ");
                ElBindingsNotificationCallback (
                        &(pwzcDeviceNotif->wmiNodeHdr),
                        0
                        );
                break;

            case WZCNOTIF_ADAPTER_UNBIND:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElBindingsNotificationCallback ");
                ElBindingsNotificationCallback (
                        &(pwzcDeviceNotif->wmiNodeHdr),
                        0
                        );
                break;
            case WZCNOTIF_MEDIA_CONNECT:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElMediaSenseCallback ");
                ElMediaSenseCallback (
                        &(pwzcDeviceNotif->wmiNodeHdr),
                        0
                        );
                break;

            case WZCNOTIF_MEDIA_DISCONNECT:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElMediaSenseCallback ");
                ElMediaSenseCallback (
                        &(pwzcDeviceNotif->wmiNodeHdr),
                        0
                        );
                break;

            case WZCNOTIF_WZC_CONNECT:
                TRACE0 (DEVICE, "ElMediaEventsHandler: Calling ElZeroConfigEvent ");
                ElZeroConfigEvent (
                        pwzcDeviceNotif->wzcConfig.dwSessionHdl,
                        pwzcDeviceNotif->wzcConfig.wszGuid,
                        pwzcDeviceNotif->wzcConfig.ndSSID,
                        &(pwzcDeviceNotif->wzcConfig.rdEventData)
                        );
                break;

            default:
                break;
        }
    }
    while (FALSE);

    return dwRetCode;
}

#endif // ZEROCONFIG_LINKED

//
// ElMediaSenseRegister
//
// Description:
//
// Function called to register CallBack function with WMI
// for MEDIA_CONNECT/MEDIA_DISCONNECT events
//
// Arguments: 
//      fRegister - True = Register for Media Sense
//                  False = Deregister Media Sense requests
// Return values:
//      NO_ERROR  - Successful
//      non-zero  - Error
//

DWORD
ElMediaSenseRegister (
        IN  BOOL        fRegister
        )
{
    DWORD       dwRetCode = NO_ERROR;
    PVOID       pvDeliveryInfo = ElMediaSenseCallback;

    dwRetCode = WmiNotificationRegistration (
                    (LPGUID)(&GUID_NDIS_STATUS_MEDIA_CONNECT),
                    (BOOLEAN)fRegister,    
                    pvDeliveryInfo,
                    (ULONG_PTR)NULL,
                    NOTIFICATION_CALLBACK_DIRECT );

    if (dwRetCode != NO_ERROR) 
    {
		TRACE1(INIT, "ElMediaSenseRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_STATUS_MEDIA_CONNECT", dwRetCode);
        return( dwRetCode );
    }

    dwRetCode = WmiNotificationRegistration (
                    (LPGUID)(&GUID_NDIS_STATUS_MEDIA_DISCONNECT),
                    (BOOLEAN)fRegister,
                    pvDeliveryInfo,
                    (ULONG_PTR)NULL,
                    NOTIFICATION_CALLBACK_DIRECT );

    if (dwRetCode != NO_ERROR)
    {
		TRACE1(INIT, "ElMediaSenseRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_STATUS_MEDIA_DISCONNECT", dwRetCode);
        return( dwRetCode );
    }

    TRACE1 (INIT, "ElMediaSenseRegister - completed with RetCode %d", dwRetCode);

    return( dwRetCode );
}


//
// ElDeviceNotificationRegister
// 
// Description:
//
// Function called to register for device addition/removal notifications
//
// Arguments: 
//      fRegister - True = Register for Device Notifications
//                  False = Deregister Device Notifications
//
// Return values:
//      NO_ERROR  - Successful
//      non-zero  - Error
//

DWORD
ElDeviceNotificationRegister (
        IN  BOOL        fRegister
        )
{
    HANDLE      hDeviceNotification = NULL;
    DWORD       dwRetCode = NO_ERROR;

#ifdef EAPOL_SERVICE

    DEV_BROADCAST_DEVICEINTERFACE   PnPFilter;

    if (fRegister)
    {
        ZeroMemory (&PnPFilter, sizeof(PnPFilter));

        PnPFilter.dbcc_size = sizeof(PnPFilter);
        PnPFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
        PnPFilter.dbcc_classguid    = GUID_NDIS_LAN_CLASS;

        g_hDeviceNotification = RegisterDeviceNotification (
                                    (HANDLE)g_hServiceStatus,
                                    &PnPFilter,
                                    DEVICE_NOTIFY_SERVICE_HANDLE );

        if (g_hDeviceNotification == NULL)
        {
            dwRetCode = GetLastError();
    
            TRACE1 (DEVICE, "ElDeviceNotificationRegister failed with error %ld",
                    dwRetCode);
        }
    }
    else
    {
        if (g_hDeviceNotification != NULL)
        {
            if (!UnregisterDeviceNotification (
                        g_hDeviceNotification
                        ))
            {
                dwRetCode = GetLastError();
                TRACE1 (DEVICE, "ElDeviceNotificationRegister: Unregister failed with error (%ld)",
                        dwRetCode);
            }
        }
    }

#endif

    return dwRetCode;
}


//
// ElBindingsNotificationRegister
//
// Description:
//
// Function called to register CallBack function with WMI
// for protocol bind/unbind
//
// Arguments: 
//      fRegister - True = Register for Media Sense
//                  False = Deregister Media Sense requests
// Return values:
//      NO_ERROR  - Successful
//      non-zero  - Error
//

DWORD
ElBindingsNotificationRegister (
        IN  BOOL        fRegister
        )
{
    DWORD       dwRetCode = NO_ERROR;
    PVOID       pvDeliveryInfo = ElBindingsNotificationCallback;

    dwRetCode = WmiNotificationRegistration (
                    (LPGUID)(&GUID_NDIS_NOTIFY_BIND),
                    (BOOLEAN)fRegister,    
                    pvDeliveryInfo,
                    (ULONG_PTR)NULL,
                    NOTIFICATION_CALLBACK_DIRECT );

    if (dwRetCode != NO_ERROR) 
    {
		TRACE1(INIT, "ElBindingsNotificationRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_NOTIFY_BIND", dwRetCode);
        return( dwRetCode );
    }

    dwRetCode = WmiNotificationRegistration (
                    (LPGUID)(&GUID_NDIS_NOTIFY_UNBIND),
                    (BOOLEAN)fRegister,
                    pvDeliveryInfo,
                    (ULONG_PTR)NULL,
                    NOTIFICATION_CALLBACK_DIRECT );

    if (dwRetCode != NO_ERROR)
    {
		TRACE1(INIT, "ElBindingsNotificationRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_NOTIFY_BIND", dwRetCode);
        return( dwRetCode );
    }

    TRACE1 (INIT, "ElBindingsNotificationRegister - completed with RetCode %d", dwRetCode);

    return( dwRetCode );
}


//
// ElDeviceNotificationHandler
// 
// Description:
//
// Function called to handle device notifications for interface addition/
// removal
//
// Arguments:
//      lpEventData - interface information
//      dwEventType - notification type 
//

DWORD
ElDeviceNotificationHandler (
        IN  VOID        *lpEventData,
        IN  DWORD       dwEventType
        )
{
    DWORD                           dwEventStatus = 0;
    DEV_BROADCAST_DEVICEINTERFACE   *pInfo = 
        (DEV_BROADCAST_DEVICEINTERFACE *) lpEventData;
    PVOID                           pvBuffer = NULL;
    BOOLEAN                         fDecrWorkerThreadCount = TRUE;
    DWORD                           dwRetCode = NO_ERROR;

    InterlockedIncrement (&g_lWorkerThreads);

    TRACE0 (DEVICE, "ElDeviceNotificationHandler entered");

    do
    {

        if (g_hEventTerminateEAPOL == NULL)
        {
            break;
        }
        if (!(g_dwModulesStarted & ALL_MODULES_STARTED))
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandler: Received notification before module started");
            break;
        }

        // Check if have already gone through EAPOLCleanUp before

        if ((dwEventStatus = WaitForSingleObject (
                    g_hEventTerminateEAPOL,
                    0)) == WAIT_FAILED)
        {
            dwRetCode = GetLastError ();
            TRACE1(INIT, "ElDeviceNotificationHandler: WaitForSingleObject failed with error %ld, Terminating !!!",
                    dwRetCode);
            // log
    
            break;
        }

        if (dwEventStatus == WAIT_OBJECT_0)
        {
            TRACE0(INIT, "ElDeviceNotificationHandler: g_hEventTerminateEAPOL already signaled, returning");
            break;
        }
    
        if (lpEventData == NULL)
        {
            dwRetCode = ERROR_INVALID_DATA;
            TRACE0 (DEVICE, "ElDeviceNotificationHandler: lpEventData == NULL");
            break;
        }
    
        if (pInfo->dbcc_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandler: Event for Interface type");
    
            if ((pvBuffer = MALLOC (pInfo->dbcc_size + 16)) == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (DEVICE, "ElDeviceNotificationHandler: MALLOC failed for pvBuffer");
                break;
            }
    
            *((DWORD *)pvBuffer) = dwEventType;
            memcpy ((PBYTE)pvBuffer + 8, (PBYTE)pInfo, pInfo->dbcc_size);
    
            if (!QueueUserWorkItem (
                (LPTHREAD_START_ROUTINE)ElDeviceNotificationHandlerWorker,
                pvBuffer,
                WT_EXECUTELONGFUNCTION))
            {
                dwRetCode = GetLastError();
                TRACE1 (DEVICE, "ElDeviceNotificationHandler: QueueUserWorkItem failed with error %ld",
                        dwRetCode);
	            break;
            }
            else
            {
                fDecrWorkerThreadCount = FALSE;
            }

        }
        else
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandler: Event NOT for Interface type");
        }

    }
    while (FALSE);
    
    TRACE1 (DEVICE, "ElDeviceNotificationHandler completed with retcode %ld",
            dwRetCode);

    if (dwRetCode != NO_ERROR)
    {
        if (pvBuffer != NULL)
        {
            FREE (pvBuffer);
        }
    }

    if (fDecrWorkerThreadCount)
    {
        InterlockedDecrement (&g_lWorkerThreads);
    }

    return dwRetCode;
}


//
// ElDeviceNotificationHandlerWorker
// 
// Description:
//
// Worker function for ElDeviceNotificationHandlerWorker
//
// Arguments:
//      pvContext - interface information
//

DWORD
WINAPI
ElDeviceNotificationHandlerWorker (
        IN  PVOID       pvContext
        )
{
    HANDLE                          hDevice = NULL;
    DEV_BROADCAST_DEVICEINTERFACE   *pInfo = NULL;
    DWORD                           dwEventType = 0;
    DWORD                           dwRetCode = NO_ERROR;

    TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Entered");

    do
    {
        if (pvContext == NULL)
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: pvContext == NULL");
            break;
        }

        if (!(g_dwModulesStarted & ALL_MODULES_STARTED))
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Received notification before module started");
            break;
        }

        dwEventType = *((DWORD *) pvContext);
        pInfo = (DEV_BROADCAST_DEVICEINTERFACE*)((PBYTE)pvContext + 8);

        if ((dwEventType == DBT_DEVICEARRIVAL) ||
                (dwEventType == DBT_DEVICEREMOVECOMPLETE))
        {
            // Extract GUID from the \Device\GUID string

            WCHAR   *pwszGUIDStart = NULL;
            WCHAR   *pwszGUIDEnd = NULL;
        
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Interface arr/rem");

            pwszGUIDStart  = wcsrchr( pInfo->dbcc_name, L'{' );
            pwszGUIDEnd    = wcsrchr( pInfo->dbcc_name, L'}' );

            if ((pwszGUIDStart != NULL) && (pwszGUIDEnd != NULL) && 
                ((pwszGUIDEnd- pwszGUIDStart) == (GUID_STRING_LEN_WITH_TERM-2)))
            {
                *(pwszGUIDEnd + 1) = L'\0';

                TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: For interface %ws",
                        pwszGUIDStart);

                // Interface was added

                if (dwEventType == DBT_DEVICEARRIVAL)
                {
                    TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device addition");
        
                    if ((dwRetCode = ElEnumAndOpenInterfaces (
                                    NULL, pwszGUIDStart, 0, NULL)) != NO_ERROR)
                    {
                        TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: ElEnumAndOpenInterfaces returned error %ld", 
                            dwRetCode);
                    }
                }
                else
                {
        
                    TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device removal");

                    if ((dwRetCode = ElShutdownInterface (pwszGUIDStart)) 
                            != NO_ERROR)
                    {
                        TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: ElShutdownInterface failed with error %ld",
                                dwRetCode);
                    }

                    if ((dwRetCode = ElEnumAndUpdateRegistryInterfaceList ()) != NO_ERROR)
                    {
                            TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: ElEnumAndUpdateRegistryInterfaceList failed with error %ld",
                                            dwRetCode);
                    }
                }
            }
            else
            {
                dwRetCode = ERROR_INVALID_PARAMETER;
                break;
            }
        }
        else
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Event type is is NOT device arr/rem");
        }

    }
    while (FALSE);

    if (pvContext != NULL)
    {
        FREE (pvContext);
    }

    TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker completed with retcode %ld",
            dwRetCode);

    InterlockedDecrement (&g_lWorkerThreads);

    return 0;
}


//
// ElMediaSenseCallback
// 
// Description:
//
// Callback function called by WMI on MEDIA_CONNECT/MEDIA_DISCONNECT 
// events
//
// Arguments:
//      pWnodeHeader - Pointer to information returned by the event
//      uiNotificationContext - unused
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

VOID
CALLBACK
ElMediaSenseCallback (
        IN PWNODE_HEADER    pWnodeHeader,
        IN UINT_PTR         uiNotificationContext
        )
{
    DWORD       dwEventStatus = 0;
    PVOID       pvBuffer = NULL;
    BOOLEAN     fDecrWorkerThreadCount = TRUE;
    DWORD       dwRetCode = NO_ERROR;

    InterlockedIncrement (&g_lWorkerThreads);

    TRACE0 (DEVICE, "ElMediaSenseCallback: Entered");

    do
    {
        if (g_hEventTerminateEAPOL == NULL)
        {
            break;
        }
        if (!(g_dwModulesStarted & ALL_MODULES_STARTED))
        {
            TRACE0 (DEVICE, "ElMediaSenseCallback: Received notification before module started");
            break;
        }

        // Check if have already gone through EAPOLCleanUp before

        if (( dwEventStatus = WaitForSingleObject (
                    g_hEventTerminateEAPOL,
                    0)) == WAIT_FAILED)
        {
            dwRetCode = GetLastError ();
            TRACE1 (INIT, "ElMediaSenseCallback: WaitForSingleObject failed with error %ld, Terminating !!!",
                    dwRetCode);
            // log
    
            break;
        }

        if (dwEventStatus == WAIT_OBJECT_0)
        {
            dwRetCode = NO_ERROR;
            TRACE0 (INIT, "ElMediaSenseCallback: g_hEventTerminateEAPOL already signaled, returning");
            break;
        }

        if (pWnodeHeader == NULL)
        {
            dwRetCode = ERROR_INVALID_DATA;
            TRACE0 (DEVICE, "ElMediaSenseCallback: pWnodeHeader == NULL");
            break;
        }

        if ((pvBuffer = MALLOC (pWnodeHeader->BufferSize)) == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            TRACE0 (DEVICE, "ElMediaSenseCallback: MALLOC failed for pvBuffer");
            break;
        }

        memcpy ((PVOID)pvBuffer, (PVOID)pWnodeHeader, pWnodeHeader->BufferSize);

        if (!QueueUserWorkItem (
            (LPTHREAD_START_ROUTINE)ElMediaSenseCallbackWorker,
            pvBuffer,
            WT_EXECUTELONGFUNCTION))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElMediaSenseCallback: QueueUserWorkItem failed with error %ld",
                    dwRetCode);
            // log

            break;
        }
        else
        {
            fDecrWorkerThreadCount = FALSE;
        }
    }
    while (FALSE);

    if (dwRetCode != NO_ERROR)
    {
        TRACE1 (DEVICE, "ElMediaSenseCallback: Failed with error %ld",
                dwRetCode);

        if (pvBuffer != NULL)
        {
            FREE (pvBuffer);
        }
    }

    if (fDecrWorkerThreadCount)
    {
        InterlockedDecrement (&g_lWorkerThreads);
    }

}


//
// ElMediaSenseCallbackWorker
// 
// Description:
//
// Worker function for ElMediaSenseCallback and executes in a separate
// thread
//
// Arguments:
//      pvContext - Pointer to information returned by the media-sense event
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

DWORD
WINAPI
ElMediaSenseCallbackWorker (
        IN  PVOID       pvContext
        )
{
    PWNODE_HEADER           pWnodeHeader = (PWNODE_HEADER)pvContext;
    PWNODE_SINGLE_INSTANCE  pWnode   = (PWNODE_SINGLE_INSTANCE)pWnodeHeader;
    WCHAR                   *pwsName = NULL;
    WCHAR                   *pwszDeviceName = NULL;
    WCHAR                   *pwsGUIDString = NULL;
    WCHAR                   *pwszDeviceGUID = NULL;
    WCHAR                   *pwszGUIDStart = NULL, *pwszGUIDEnd = NULL;
    DWORD                   dwGUIDLen = 0;
    USHORT                  cpsLength;
    EAPOL_ITF               *pITF;
    EAPOL_PCB               *pPCB = NULL;
    DWORD                   dwRetCode = NO_ERROR;

    do
    {

#ifdef EAPOL_SERVICE

    if ((g_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
         ||
         (g_ServiceStatus.dwCurrentState == SERVICE_STOPPED))
    {
        TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Callback received while service was stopping");
        break;
    }

#endif // EAPOL_SERVICE

    if (pWnodeHeader == NULL)
    {
        TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Callback received with NULL NDIS interface details");

        break;
    }

    pwsName = (PWCHAR)RtlOffsetToPointer(
                                    pWnode,
                                    pWnode->OffsetInstanceName );

    pwsGUIDString = (PWCHAR)RtlOffsetToPointer(
                                    pWnode,
                                    pWnode->DataBlockOffset );

    cpsLength = (SHORT)( *((SHORT *)pwsName) );

    if (!(pwszDeviceName = (WCHAR *) MALLOC ((cpsLength+1)*sizeof(WCHAR))))
    {
        TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Error in Memory allocation for pszDeviceName");
        break;
    }

    memcpy ((CHAR *)pwszDeviceName, (CHAR *)pwsName+sizeof(SHORT), cpsLength);
    pwszDeviceName[cpsLength] = L'\0';

    pwszGUIDStart = wcschr (pwsGUIDString, L'{');
    pwszGUIDEnd = wcschr (pwsGUIDString, L'}');

    if ((pwszGUIDStart == NULL) || (pwszGUIDEnd == NULL) || ((pwszGUIDEnd - pwszGUIDStart) != (GUID_STRING_LEN_WITH_TERM-2)))
    {
        TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: GUID not constructed correctly");
        dwRetCode = ERROR_INVALID_PARAMETER;
        break;
    }

    dwGUIDLen = GUID_STRING_LEN_WITH_TERM;
    pwszDeviceGUID = NULL;
    if ((pwszDeviceGUID = MALLOC (dwGUIDLen * sizeof (WCHAR))) == NULL)
    {
        TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: MALLOC failed for pwszDeviceGUID");
        dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
        break;
    }

    memcpy ((VOID *)pwszDeviceGUID, (VOID *)pwszGUIDStart, ((dwGUIDLen-1)*sizeof(WCHAR)));
    pwszDeviceGUID[dwGUIDLen-1] = L'\0';

    TRACE3 (DEVICE, "ElMediaSenseCallbackWorker: For interface (%ws), GUID (%ws), length of block = %d", 
            pwszDeviceName, pwszDeviceGUID, cpsLength);

    //
    // Get the information for the media disconnect.
    //

    if (memcmp( &(pWnodeHeader->Guid), 
                 &GUID_NDIS_STATUS_MEDIA_DISCONNECT, 
                 sizeof(GUID)) == 0)
    {
        // MEDIA DISCONNECT callback 

        DbLogPCBEvent (DBLOG_CATEG_INFO, NULL, EAPOL_MEDIA_DISCONNECT, pwszDeviceName);

        // Check if EAPOL was actually started on this interface
        // Verify by checking existence of corresponding entry in hash table

        TRACE0(DEVICE, "ElMediaSenseCallbackWorker: Callback for sense disconnect");

        ACQUIRE_WRITE_LOCK (&(g_PCBLock));
        pPCB = ElGetPCBPointerFromPortGUID (pwszDeviceGUID);
        if (pPCB != NULL)
        {
            ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
            if ((dwRetCode = FSMDisconnected (pPCB, NULL)) != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: FSMDisconnected failed with error %ld", 
                    dwRetCode);
            }
            else
            {
                TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Port marked disconnected %ws", 
                    pwszDeviceName);
            }
            RELEASE_WRITE_LOCK (&(pPCB->rwLock));
        }
        RELEASE_WRITE_LOCK (&(g_PCBLock));
    }
    else
    {
        if (memcmp( &(pWnodeHeader->Guid), 
                     &GUID_NDIS_STATUS_MEDIA_CONNECT, 
                     sizeof(GUID)) == 0)
        {
            // MEDIA CONNECT callback

            DbLogPCBEvent (DBLOG_CATEG_INFO, NULL, EAPOL_MEDIA_CONNECT, pwszDeviceName);

            TRACE0(DEVICE, "ElMediaSenseCallbackWorker: Callback for sense connect");

            if ((dwRetCode = ElEnumAndOpenInterfaces (
                            NULL, pwszDeviceGUID, 0, NULL))
                != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: ElEnumAndOpenInterfaces returned error %ld", 
                        dwRetCode);
            }
        }
    }

    }
    while (FALSE);

    TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: processed, RetCode = %ld", dwRetCode);


    if (pWnodeHeader != NULL)
    {
        FREE (pWnodeHeader);
    }

    if (pwszDeviceName != NULL)
    {
        FREE (pwszDeviceName);
    }

    if (pwszDeviceGUID != NULL)
    {
        FREE (pwszDeviceGUID);
    }

    InterlockedDecrement (&g_lWorkerThreads);

    return 0;
}


//
// ElBindingsNotificationCallback
// 
// Description:
//
// Callback function called by WMI on protocol bind/unbind
// events
//
// Arguments:
//      pWnodeHeader - Pointer to information returned by the event
//      uiNotificationContext - unused
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

VOID
CALLBACK
ElBindingsNotificationCallback (
        IN PWNODE_HEADER    pWnodeHeader,
        IN UINT_PTR         uiNotificationContext
        )
{
    DWORD       dwEventStatus = 0;
    PVOID       pvBuffer = NULL;
    BOOLEAN     fDecrWorkerThreadCount = TRUE;
    DWORD       dwRetCode = NO_ERROR;

    InterlockedIncrement (&g_lWorkerThreads);

    TRACE0 (DEVICE, "ElBindingsNotificationCallback: Entered");

    do
    {
        if (g_hEventTerminateEAPOL == NULL)
        {
            break;
        }
        if (!(g_dwModulesStarted & ALL_MODULES_STARTED))
        {
            TRACE0 (DEVICE, "ElBindingsNotificationCallback: Received notification before module started");
            break;
        }

        // Check if have already gone through EAPOLCleanUp before

        if (( dwEventStatus = WaitForSingleObject (
                    g_hEventTerminateEAPOL,
                    0)) == WAIT_FAILED)
        {
            dwRetCode = GetLastError ();
            TRACE1 (INIT, "ElBindingsNotificationCallback: WaitForSingleObject failed with error %ld, Terminating !!!",
                    dwRetCode);
            break;
        }

        if (dwEventStatus == WAIT_OBJECT_0)
        {
            dwRetCode = NO_ERROR;
            TRACE0 (INIT, "ElBindingsNotificationCallback: g_hEventTerminateEAPOL already signaled, returning");
            break;
        }

        if (pWnodeHeader == NULL)
        {
            dwRetCode = ERROR_INVALID_DATA;
            TRACE0 (DEVICE, "ElBindingsNotificationCallback: pWnodeHeader == NULL");
            break;
        }

        if ((pvBuffer = MALLOC (pWnodeHeader->BufferSize)) == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            TRACE0 (DEVICE, "ElBindingsNotificationCallback: MALLOC failed for pvBuffer");
            break;
        }

        memcpy ((PVOID)pvBuffer, (PVOID)pWnodeHeader, pWnodeHeader->BufferSize);

        if (!QueueUserWorkItem (
            (LPTHREAD_START_ROUTINE)ElBindingsNotificationCallbackWorker,
            pvBuffer,
            WT_EXECUTELONGFUNCTION))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElBindingsNotificationCallback: QueueUserWorkItem failed with error %ld",
                    dwRetCode);
            // log

            break;
        }
        else
        {
            fDecrWorkerThreadCount = FALSE;
        }
    
    }
    while (FALSE);

    if (dwRetCode != NO_ERROR)
    {
        TRACE1 (DEVICE, "ElBindingsNotificationCallback: Failed with error %ld",
                dwRetCode);

        if (pvBuffer != NULL)
        {
            FREE (pvBuffer);
        }
    }

    if (fDecrWorkerThreadCount)
    {
        InterlockedDecrement (&g_lWorkerThreads);
    }

}


//
// ElBindingsNotificationCallbackWorker
// 
// Description:
//
// Worker function for ElBindingsNotificationCallback and executes in a separate
// thread
//
// Arguments:
//      pvContext - Pointer to information returned by the protocol bind/unbind 
//                  event
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

DWORD
WINAPI
ElBindingsNotificationCallbackWorker (
        IN  PVOID       pvContext
        )
{
    PWNODE_HEADER           pWnodeHeader = (PWNODE_HEADER)pvContext;
    PWNODE_SINGLE_INSTANCE  pWnode   = (PWNODE_SINGLE_INSTANCE)pWnodeHeader;
    WCHAR                   *pwsName = NULL;
    WCHAR                   *pwszDeviceGUID = NULL;
    WCHAR                   *pwszGUIDStart = NULL, *pwszGUIDEnd = NULL;
    DWORD                   dwGUIDLen = 0;
    WCHAR                   *pwsTransportName = NULL;
    WCHAR                   *pwszDeviceName = NULL;
    USHORT                  cpsLength;
    EAPOL_ITF               *pITF = NULL;
    EAPOL_PCB               *pPCB = NULL;
    DWORD                   dwRetCode = NO_ERROR;

    do
    {

#ifdef EAPOL_SERVICE

    if ((g_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
         ||
         (g_ServiceStatus.dwCurrentState == SERVICE_STOPPED))
    {
        TRACE0 (DEVICE, "ElBindingsNotificationCallbackWorker: Callback received while service was stopping");
        break;
    }

#endif // EAPOL_SERVICE

    if (pWnodeHeader == NULL)
    {
        TRACE0 (DEVICE, "ElBindingsNotificationCallbackWorker: Callback received with NULL NDIS interface details");

        break;
    }

    pwsName = (PWCHAR)RtlOffsetToPointer(
                                    pWnode,
                                    pWnode->OffsetInstanceName );

    pwsTransportName = (PWCHAR)RtlOffsetToPointer(
                                    pWnode,
                                    pWnode->DataBlockOffset );

    if (wcsncmp (cwszNDISUIOProtocolName, pwsTransportName, wcslen (cwszNDISUIOProtocolName)))
    {
        TRACE1 (DEVICE, "ElBindingsNotificationCallbackWorker: Protocol binding (%ws) not for NDISUIO",
                pwsTransportName);
        break;
    }

    // Get the length of the device name string and null terminate it 

    cpsLength = (SHORT)( *((SHORT *)pwsName) );

    if (!(pwszDeviceName = (WCHAR *) MALLOC ((cpsLength+1)*sizeof(WCHAR))))
    {
        TRACE0 (DEVICE, "ElBindingsNotificationCallbackWorker: Error in Memory allocation for pwszDeviceName");
        break;
    }

    memcpy ((CHAR *)pwszDeviceName, (CHAR *)pwsName+sizeof(SHORT), cpsLength);
    pwszDeviceName[cpsLength] = L'\0';

    pwszDeviceGUID = pwsTransportName + wcslen(cwszNDISUIOProtocolName) + 1;

    pwszGUIDStart = wcschr (pwszDeviceGUID, L'{');
    pwszGUIDEnd = wcschr (pwszDeviceGUID, L'}');

    pwszDeviceGUID = NULL;

    if ((pwszGUIDStart == NULL) || (pwszGUIDEnd == NULL) || ((pwszGUIDEnd - pwszGUIDStart) != (GUID_STRING_LEN_WITH_TERM-2)))
    {
        TRACE0 (DEVICE, "ElBindingsNotificationCallbackWorker: GUID not constructed correctly");
        dwRetCode = ERROR_INVALID_PARAMETER;
        break;
    }

    dwGUIDLen = GUID_STRING_LEN_WITH_TERM;
    if ((pwszDeviceGUID = MALLOC (dwGUIDLen * sizeof (WCHAR))) == NULL)
    {
        TRACE0 (DEVICE, "ElBindingsNotificationCallbackWorker: MALLOC failed for pwszDeviceGUID");
        dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
        break;
    }

    memcpy ((VOID *)pwszDeviceGUID, (VOID *)pwszGUIDStart, ((dwGUIDLen-1)*sizeof(WCHAR)));
    pwszDeviceGUID[dwGUIDLen-1] = L'\0';

    TRACE2 (DEVICE, "ElBindingsNotificationCallbackWorker: For interface = %ws, guid=%ws", 
            pwszDeviceName, pwszDeviceGUID);
    
    //
    // Get the information for the protocol UNBIND
    //

    if (memcmp( &(pWnodeHeader->Guid), 
                 &GUID_NDIS_NOTIFY_UNBIND, 
                 sizeof(GUID)) == 0)
    {
        // Protocol UNBIND callback 

        DbLogPCBEvent (DBLOG_CATEG_INFO, NULL, EAPOL_NDISUIO_UNBIND, pwszDeviceName);

        TRACE0(DEVICE, "ElBindingsNotificationCallbackWorker: Callback for protocol unbind");

        if ((dwRetCode = ElShutdownInterface (pwszDeviceGUID)) != ERROR)
        {
            TRACE2 (DEVICE, "ElBindingsNotificationCallbackWorker: ElShutdownInterface failed with error %ld for (%ws)",
                    dwRetCode, pwszDeviceGUID);
        }
                    
        if ((dwRetCode = ElEnumAndUpdateRegistryInterfaceList ()) != NO_ERROR)
        {
            TRACE1 (DEVICE, "ElBindingsNotificationCallbackWorker: ElEnumAndUpdateRegistryInterfaceList failed with error %ld",
                                dwRetCode);
        }
    }
    else
    {

        if (memcmp( &(pWnodeHeader->Guid), 
                     &GUID_NDIS_NOTIFY_BIND, 
                     sizeof(GUID)) == 0)
        {
            // protocol BIND callback

            DbLogPCBEvent (DBLOG_CATEG_INFO, NULL, EAPOL_NDISUIO_BIND, pwszDeviceName);

            TRACE0(DEVICE, "ElBindingsNotificationCallbackWorker: Callback for protocol BIND");

            if ((dwRetCode = ElEnumAndOpenInterfaces (
                            NULL, pwszDeviceGUID, 0, NULL))
                                                        != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElBindingsNotificationCallbackWorker: ElEnumAndOpenInterfaces returned error %ld", 
                        dwRetCode);
            }
        }
    }

    }
    while (FALSE);

    TRACE1 (DEVICE, "ElBindingsNotificationCallbackWorker: processed, RetCode = %ld", dwRetCode);

    if (pWnodeHeader != NULL)
    {
        FREE (pWnodeHeader);
    }

    if (pwszDeviceName != NULL)
    {
        FREE (pwszDeviceName);
    }

    if (pwszDeviceGUID != NULL)
    {
        FREE (pwszDeviceGUID);
    }

    InterlockedDecrement (&g_lWorkerThreads);

    return 0;
}


// 
// ElEnumAndOpenInterfaces
// 
// Description:
//
// Enumerates interfaces and intializes EAPOL on desired ones.
//
// If EAPOL is to be started on an interface, it opens a handle to 
// the NDISUIO driver, calls EAPOL to create and initialize PCB for the 
// interface, and finally adds an entry to the interface hashtable.
//
// If pwszDesiredGUID is not NULL, all interfaces are enumerated, but 
// EAPOL will be initialized only on the interface whose GUID matches.
//
// If pwszDesiredDescription is not NULL, all interfaces are enumerated, but 
// EAPOL will be initialized only on the interface whose description matches.
//
// If pwszDesiredGUID and pwszDescription are both NULL, all interfaces are 
// enumerated. EAPOL will be initialized only on all interfaces that 
// does have an entry in the interface hashtable.
//
//
// Arguments:
//      pwszDesiredDescription - Interface Description on which EAPOL is to 
//                  be started
//      pwszDesiredGUID - Interface GUID on which EAPOL is to be started
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

DWORD
ElEnumAndOpenInterfaces (
        WCHAR       *pwszDesiredDescription,
        WCHAR       *pwszDesiredGUID,
        DWORD       dwHandle,
        PRAW_DATA   prdUserData
        )
{ 
    CHAR				EnumerateBuffer[256];
    PNDIS_ENUM_INTF		Interfaces = NULL;
    BYTE                *pbNdisuioEnumBuffer = NULL;
    DWORD               dwNdisuioEnumBufferSize = 0;
    HANDLE              hDevice = NULL;
    BOOL                fSearchByDescription = FALSE;
    BOOL                fSearchByGUID = FALSE;
    DWORD               dwEapTypeToBeUsed = DEFAULT_EAP_TYPE;
    WCHAR               cwsDummyBuffer[256], *pDummyPtr = NULL;
    WCHAR               *pwszGUIDStart = NULL;
    EAPOL_PCB           *pPCB = NULL;
    BOOL                fPCBExists = FALSE;
    BOOL                fPCBReferenced = FALSE;
    DWORD               dwAvailableInterfaces = 0;
    EAPOL_INTF_PARAMS   EapolIntfParams;
    DWORD               dwRetCode = NO_ERROR;


    TRACE2 (DEVICE, "ElEnumAndOpenInterfaces: DeviceDesc = %ws, GUID = %ws",
            pwszDesiredDescription, pwszDesiredGUID);
        
    ACQUIRE_WRITE_LOCK (&(g_ITFLock));

    if (pwszDesiredGUID == NULL)
    {
        if (pwszDesiredDescription != NULL)
        {
            fSearchByDescription = TRUE;
        }
    }
    else
    {
        if (pwszDesiredDescription != NULL)
        {
            RELEASE_WRITE_LOCK (&(g_ITFLock));
            return ERROR;
        }
        fSearchByGUID = TRUE;
    }

    ZeroMemory (EnumerateBuffer, 256);
    Interfaces = (PNDIS_ENUM_INTF)EnumerateBuffer;

    //
    // Allocate amount of memory as instructed by NdisEnumerateInterfaces
    // once the API allows querying of bytes required
    //

    Interfaces->TotalInterfaces = 0;
    Interfaces->AvailableInterfaces = 0;
    Interfaces->BytesNeeded = 0;
    if (!NdisEnumerateInterfaces(Interfaces, 256)) 
    {
        RELEASE_WRITE_LOCK (&(g_ITFLock));
        dwRetCode = GetLastError ();
        TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: NdisEnumerateInterfaces failed with error %ld",
                dwRetCode);
        return dwRetCode;
    }

    dwNdisuioEnumBufferSize = (Interfaces->BytesNeeded + 7) & 0xfffffff8;
    dwAvailableInterfaces = Interfaces->AvailableInterfaces;

    if (dwNdisuioEnumBufferSize == 0)
    {
        RELEASE_WRITE_LOCK (&(g_ITFLock));
        TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: MALLOC skipped for pbNdisuioEnumBuffer as dwNdisuioEnumBufferSize == 0");
        dwRetCode = NO_ERROR;
        return dwRetCode;
    }

    pbNdisuioEnumBuffer = (BYTE *) MALLOC (4*dwNdisuioEnumBufferSize);

    if (pbNdisuioEnumBuffer == NULL)
    {
        RELEASE_WRITE_LOCK (&(g_ITFLock));
        dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
        TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: MALLOC failed for pbNdisuioEnumBuffer");
        return dwRetCode;
    }

    Interfaces = (PNDIS_ENUM_INTF)pbNdisuioEnumBuffer;

    // Enumerate all the interfaces present on the machine

    if ((dwRetCode = ElNdisuioEnumerateInterfaces (
                            Interfaces, 
                            dwAvailableInterfaces,
                            4*dwNdisuioEnumBufferSize)) == NO_ERROR)
    {
        UNICODE_STRING  *pInterfaceName = NULL;
        UNICODE_STRING  *pInterfaceDescription = NULL;
        DWORD			i;

        // Update the interface list in the registry that NDISUIO has bound to.
        // The current interface list is just overwritten into the registry.


        if ((dwRetCode = ElUpdateRegistryInterfaceList (Interfaces)) 
                != NO_ERROR)
        {
            TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: ElUpdateInterfaceList failed with error =%ld", 
                    dwRetCode);

            dwRetCode = NO_ERROR;

            // log
        }

        for (i=0; i < Interfaces->TotalInterfaces; i++)
        {
            fPCBExists = fPCBReferenced = FALSE;
            if ((dwRetCode != NO_ERROR) &&
                    (fSearchByDescription || fSearchByGUID))
            {
                break;
            }
            else
            {
                dwRetCode = NO_ERROR;
            }

            if (Interfaces->Interface[i].DeviceName.Buffer != NULL)
            {
                pInterfaceName = &(Interfaces->Interface[i].DeviceName);
            }
            else
            {
                TRACE0(INIT, "NdisEnumerateInterfaces: Device Name was NULL");
                continue;
            }

            TRACE1(INIT, "Device: %ws", pInterfaceName->Buffer);

                    
            if (Interfaces->Interface[i].DeviceDescription.Buffer != NULL)
            {
                pInterfaceDescription = &(Interfaces->Interface[i].DeviceDescription);
            }
            else
            {
                TRACE0(INIT, "NdisEnumerateInterfaces: Device Description was NULL");
                continue;
            }

            TRACE1(INIT, "Description: %ws", pInterfaceDescription->Buffer);

            // EAPOL requested be started only a particular
            // interface

            if (fSearchByDescription)
            {
                if (wcscmp (pInterfaceDescription->Buffer,
                            pwszDesiredDescription)
                        != 0)
                {
                    // No match, continue with next interface
                    continue;
                }

                TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %ws", pInterfaceDescription->Buffer);
            }

            if (fSearchByGUID)
            {
                if (wcsstr (pInterfaceName->Buffer,
                            pwszDesiredGUID)
                        == NULL)
                {
                    // No match, continue with next interface
                    continue;
                }

                TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %ws", pInterfaceName->Buffer);
            }

            {
                // Extract GUID-string out of device name

                WCHAR   *pwszGUIDEnd = NULL;
                WCHAR   *pwszGUID = NULL;
                WCHAR   wchGUIDSaveLast;

                pwszGUID = pInterfaceName->Buffer;
                pwszGUIDStart  = wcschr( pwszGUID, L'{' );
                pwszGUIDEnd    = wcschr( pwszGUID, L'}' );

                    
                if (pwszGUIDStart != NULL)
                {
                    wchGUIDSaveLast = *(pwszGUIDEnd+1);
                    
                    *(pwszGUIDEnd+1) = (WCHAR)NULL;
                }

                // Verify if a PCB already exists for the interface
                // This is possible if no media disconnect was received
                // after the initial media connect

                pPCB = NULL;
                hDevice = NULL;

                ACQUIRE_WRITE_LOCK (&(g_PCBLock));
                if ((pPCB = ElGetPCBPointerFromPortGUID (pwszGUIDStart)) != NULL)
                {
                    if (EAPOL_REFERENCE_PORT (pPCB))
                    {
                        fPCBReferenced = TRUE;
                    }
                }
                RELEASE_WRITE_LOCK (&(g_PCBLock));

                // Restore interface buffer

                *(pwszGUIDEnd+1) = wchGUIDSaveLast;

                if (pPCB != NULL)
                {
                    // Point to existing handle

                    hDevice = pPCB->hPort;
                    fPCBExists = TRUE;
                    dwRetCode = NO_ERROR;
                    TRACE0 (INIT, "ElEnumAndOpenInterfaces: Found PCB already existing for interface");
                }
                else
                {
                    TRACE0 (INIT, "ElEnumAndOpenInterfaces: Did NOT find PCB already existing for interface");

                    // Open handle to ndisuio driver

                    if ((dwRetCode = ElOpenInterfaceHandle (
                                    pInterfaceName->Buffer,
                                    &hDevice
                                    )) != NO_ERROR)
                    {
                        TRACE1 (INIT, "ElEnumAndOpenInterfaces: ElOpenInterfaceHandle failed with error = %d\n",
                            dwRetCode );
                    }
                }

                *(pwszGUIDEnd+1) = (CHAR)NULL;

            }

            if (dwRetCode != NO_ERROR)
            {
                TRACE0 (INIT, "ElEnumAndOpenInterfaces: Failed to open handle");
                continue;
            }
            else
            {
                // Create EAPOL PCB and start state machine

                if ((dwRetCode = ElCreatePort (
                                hDevice,
                                pwszGUIDStart,
                                pInterfaceDescription->Buffer,
                                dwHandle,
                                prdUserData
                                )) != NO_ERROR)
                {
                    TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in CreatePort = %d", dwRetCode);

                    if (fPCBExists)
                    {
                        if (dwRetCode = ElShutdownInterface (
                                            pPCB->pwszDeviceGUID
                                            ) != NO_ERROR)
                        {
                            TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: ElShutdownInterface handle 1 failed with error %ld",
                                        dwRetCode);
                        }
                        if (fPCBReferenced)
                        {
                            EAPOL_DEREFERENCE_PORT (pPCB);
                        }
                    }
                    else
                    {
                        // Close the handle just opened to the ndisuio driver

                        if ((dwRetCode = ElCloseInterfaceHandle (
                                        hDevice, 
                                        pwszGUIDStart)) != NO_ERROR)
                        {
                            TRACE1 (DEVICE, 
                                "ElEnumAndOpenInterfaces: Error in ElCloseInterfaceHandle %d", 
                                dwRetCode);
                        }
                    }

                    // Continue with the next interface

                    continue;
                }
                else
                {
                    TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: CreatePort successful");

                    // If PCB already existed, do not add to the hash
                    // table

                    if (fPCBExists)
                    {
                        TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: PCB already existed, skipping Interface hash table addition");
                        fPCBExists = FALSE;
                        if (fPCBReferenced)
                        {
                            EAPOL_DEREFERENCE_PORT (pPCB);
                        }
                        continue;
                    }

                    if ((dwRetCode = ElCreateInterfaceEntry (
                                        pwszGUIDStart,
                                        pInterfaceDescription->Buffer
                                    )) != NO_ERROR)
                    {
                        // Could not create new interface entry
                        // Delete Port entry created for this GUID

                        if ((dwRetCode = ElDeletePort (
                                        pwszGUIDStart,
                                        &hDevice)) != NO_ERROR)
                        {
        
                            TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in deleting port for %ws", 
                                    pwszGUIDStart);
                            // log
                        }

                        // Close the handle to the NDISUIO driver

                        if ((dwRetCode = ElCloseInterfaceHandle (
                                        hDevice, 
                                        pwszGUIDStart)) != NO_ERROR)
                        {
                            TRACE1 (DEVICE, 
                                    "ElEnumAndOpenInterfaces: Error in ElCloseInterfaceHandle %d", 
                                    dwRetCode);
                            // log
                        }
                    }
                }
            }
        } // for (i=0; i < Interfaces
    }
    else
    {
        TRACE1(INIT, "ElEnumAndOpenInterfaces: ElNdisuioEnumerateInterfaces failed with error %d", 
                dwRetCode);
    }

    TRACE1(INIT, "ElEnumAndOpenInterfaces: Completed with retcode = %d", 
            dwRetCode);

    if (pbNdisuioEnumBuffer != NULL)
    {
        FREE(pbNdisuioEnumBuffer);
    }

    RELEASE_WRITE_LOCK (&(g_ITFLock));

    return dwRetCode;
}


//
// ElOpenInterfaceHandle
// 
// Description:
//
// Function called to open handle to the NDISUIO driver for an interface.
//
// Arguments:
//      DeviceName - Identifier for the interface is of the 
//                     form \Device\{GUID String}
//      phDevice - Output pointer to handle of NDISUIO driver for 
//                      the interface
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElOpenInterfaceHandle (
        IN  WCHAR       *pwszDeviceName,
        OUT HANDLE      *phDevice
        )
{
    DWORD   dwDesiredAccess;
    DWORD   dwShareMode;
    LPSECURITY_ATTRIBUTES   lpSecurityAttributes = NULL;
    DWORD   dwCreationDistribution;
    DWORD   dwFlagsAndAttributes;
    HANDLE  hTemplateFile;
    HANDLE  hHandle = INVALID_HANDLE_VALUE;
    DWORD   dwRetCode = NO_ERROR;
    WCHAR   wNdisDeviceName[MAX_NDIS_DEVICE_NAME_LEN];
    INT     wNameLength;
    INT     NameLength = wcslen(pwszDeviceName);
    DWORD   dwBytesReturned;
    USHORT  wEthernetType = g_wEtherType8021X;
    INT     i;

    dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
    dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
    dwCreationDistribution = OPEN_EXISTING;
    dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
    hTemplateFile = (HANDLE)INVALID_HANDLE_VALUE;

    TRACE1 (INIT, "ElOpenInterfaceHandle: Opening handle for %ws", 
            pwszDeviceName);

    do 
    {

        // Convert to unicode string - non-localized...
        
        wNameLength = 0;
        for (i = 0; (i < NameLength) && (i < MAX_NDIS_DEVICE_NAME_LEN-1); i++)
        {
            wNdisDeviceName[i] = (WCHAR)pwszDeviceName[i];
            wNameLength++;
        }
        wNdisDeviceName[i] = L'\0';
    
        TRACE1(DEVICE, "ElOpenInterfaceHandle: Trying to access NDIS Device: %ws\n", 
                wNdisDeviceName);

        // --ft: Replace these calls to Ndisuio with the calls to the opened handles hash.
        //hHandle = CreateFileA(
        //            pNdisuioDevice,
        //            dwDesiredAccess,
        //            dwShareMode,
        //            lpSecurityAttributes,
        //            dwCreationDistribution,
        //            dwFlagsAndAttributes,
        //            hTemplateFile
        //            );
        //
        //if (hHandle == INVALID_HANDLE_VALUE)
        //{
        //    *phDevice = NULL;
        //    dwRetCode = GetLastError();
        //    TRACE1 (INIT, "ElOpenInterfaceHandle: Failed in CreateFile with error %d", dwRetCode);
        //    break;
        //}
        //else
        //{
        //    *phDevice = hHandle;
        //}
        //
        //if (!(DeviceIoControl(
        //        *phDevice,
        //        IOCTL_NDISUIO_OPEN_DEVICE,
        //        (LPVOID)&wNdisDeviceName[0],
        //        wNameLength*sizeof(WCHAR),
        //        NULL,
        //        0,
        //        &dwBytesReturned,
        //        NULL)))
        //        
        //{
        //    *phDevice = NULL;
        //    if ((dwRetCode = GetLastError()) == 0)
        //    {
        //        dwRetCode = ERROR_IO_DEVICE;
        //    }
        //    TRACE1(DEVICE, "ElOpenInterfaceHandle: Error in accessing NDIS Device: %ws", wNdisDeviceName);
        //    break;
        //}
        // The call below goes to the opened handles hash which takes care of
        // sharing the handles. EAPOL doesn't have to care about anyone else
        // using this handle - the sharing hash keeps a ref count for the handle
        // such that the callers can just call OpenIntfHandle & CloseIntfHandle
        // whenever they wish.
        dwRetCode = OpenIntfHandle(
                        wNdisDeviceName,
                        &hHandle);

        if (dwRetCode != ERROR_SUCCESS)
        {
            TRACE1(DEVICE, "ElOpenInterfaceHandle: Error in OpenIntfHandle(%ws)", wNdisDeviceName);
            break;
        }
        *phDevice = hHandle;

        TRACE2(DEVICE, "ElOpenInterfaceHandle: OpenIntfHandle(%ws) = %d", wNdisDeviceName, *phDevice);

        // IOCTL down the Ethernet type

        if (!(DeviceIoControl(
                *phDevice,
                IOCTL_NDISUIO_SET_ETHER_TYPE,
                (LPVOID)&wEthernetType,
                sizeof(USHORT),
                NULL,
                0,
                &dwBytesReturned,
                NULL)))
                
        {
            *phDevice = NULL;
            if ((dwRetCode = GetLastError()) == 0)
            {
                dwRetCode = ERROR_IO_DEVICE;
            }
            TRACE1(DEVICE, "ElOpenInterfaceHandle: Error in ioctling ETHER type : %ws", wNdisDeviceName);
            break;
        }

        // Bind for asynchronous I/O handling of Read/Write data
        // Depending on whether it is completion for Readfile() or WriteFile()
        // ElIoCompletionRoutine will call ElReadCompletionRoutine
        // or ElWriteCompletionRoutine
       
        if (!BindIoCompletionCallback(
                *phDevice,
                ElIoCompletionRoutine,
                0
                ))
        {
            dwRetCode = GetLastError();
            if (dwRetCode != ERROR_INVALID_PARAMETER)
            {
                *phDevice = NULL;
                TRACE1 (DEVICE, "ElOpenInterfaceHandle: Error in BindIoCompletionCallBac %d", dwRetCode);
                break;
            }
            else
            {
                TRACE0 (DEVICE, "ElOpenInterfaceHandle: BindIoCompletionCallback already done !!!");
                dwRetCode = NO_ERROR;
            }
        }
        
    } while (FALSE);

    // Cleanup if there is error

    if (dwRetCode != NO_ERROR)
    {
        if (hHandle != INVALID_HANDLE_VALUE)
        {
            // --ft: if anything bad happened, don't overwrite the dwRetCode - we're interested
            // what the first error was, not the error that might have happened when we
            // tried to close the hHandle.
            // Note: ElCloseInterfaceHandle understands the Guid both decorated and un-decorated
            if (ElCloseInterfaceHandle(hHandle, pwszDeviceName) != ERROR_SUCCESS)
            {
                TRACE1 (INIT, "ElOpenInterfaceHandle: Error in CloseHandle %d", dwRetCode);
            }
        }
    }
        
    TRACE2 (INIT, "ElOpenInterfaceHandle: Opened handle %p with dwRetCode %d", *phDevice, dwRetCode);

    return (dwRetCode);

}


//
// ElCloseInterfaceHandle
// 
// Description:
//
// Function called to close handle to NDISUIO driver for an interface 
//
// Arguments:
//      hDevice - Handle to NDISUIO device for the interface
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElCloseInterfaceHandle (
        IN  HANDLE      hDevice,
        IN  LPWSTR      pwszDeviceGuid
        )
{
    DWORD   dwRetCode = ERROR_SUCCESS;
    WCHAR   wNdisDeviceName[MAX_NDIS_DEVICE_NAME_LEN];

    TRACE2 (DEVICE, "ElCloseInterfaceHandle(0x%x,%ws) entered", hDevice, pwszDeviceGuid);

    ZeroMemory (wNdisDeviceName, MAX_NDIS_DEVICE_NAME_LEN);

    // if first char in the Guid is '\' then we assume the GUID format is
    // '\DEVICE\{...}'. We do just the UNICODE conversion then
    if (pwszDeviceGuid[0] == '\\')
    {
        wcscpy (wNdisDeviceName, pwszDeviceGuid);
    }
    // else, we assume the Guid is un-decorated, and we add the decorations.
    else
    {
        wcscpy(wNdisDeviceName, L"\\DEVICE\\");
        wcsncat(wNdisDeviceName, pwszDeviceGuid, MAX_NDIS_DEVICE_NAME_LEN - 8);
        wNdisDeviceName[MAX_NDIS_DEVICE_NAME_LEN-1]=L'\0';
    }

    // --ft: For now, don't go directly to Ndisuio to close handles. Instead,
    // go to the opened handles hash. This takes care of all the handle sharing
    // problem.
    dwRetCode = CloseIntfHandle(wNdisDeviceName);

    //if (!CloseHandle(hDevice))
    //{
    //    dwRetCode = GetLastError();
    //}

    if (dwRetCode != ERROR_SUCCESS)
    {
        TRACE1 (INIT, "ElCloseInterfaceHandle: Error in CloseHandle %d", 
                dwRetCode);
    }

    return dwRetCode;
}


//
// ElReadFromInterface
// 
// Description:
//
// Function called to perform Overlapped read on handle to NDISUIO driver
//
// Arguments:
//      hDevice - Handle to NDISUIO driver for this interface
//      pElBuffer - Context buffer
//      dwBufferLength - Bytes to be read
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElReadFromInterface (
        IN HANDLE           hDevice,
        IN PEAPOL_BUFFER    pElBuffer,
        IN DWORD            dwBufferLength
        )
{
    DWORD   dwRetCode = NO_ERROR;

    if (!ReadFile (
                hDevice,
                pElBuffer->pBuffer,
                dwBufferLength,
                NULL,
                &pElBuffer->Overlapped
                ))
    {
        dwRetCode = GetLastError();
            
        if (dwRetCode == ERROR_IO_PENDING)
        {
            // Pending status is fine, we are doing OVERLAPPED read

            dwRetCode = NO_ERROR;
        }
        else
        {
            TRACE1 (DEVICE, "ElReadFromInterface: ReadFile failed with error %d",
                    dwRetCode);
        }
    }

    return dwRetCode;
}


//
// ElWriteToInterface
// 
// Description:
//
// Function called to perform Overlapped write on handle to NDISUIO driver
//
// Arguments:
//      hDevice - Handle to NDISUIO device for this interface
//      pElBuffer - Context buffer
//      dwBufferLength - Bytes to be written
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElWriteToInterface (
        IN HANDLE           hDevice,
        IN PEAPOL_BUFFER    pElBuffer,
        IN DWORD            dwBufferLength
        )
{
    DWORD   dwRetCode = NO_ERROR;
    
    TRACE0 (DEVICE, "ElWriteToInterface entered");

    if (!WriteFile (
                hDevice,
                pElBuffer->pBuffer,
                dwBufferLength,
                NULL,
                &pElBuffer->Overlapped
                ))
    {
        dwRetCode = GetLastError();
            
        if (dwRetCode == ERROR_IO_PENDING)
        {
            // Pending status is fine, we are doing OVERLAPPED write

            dwRetCode = NO_ERROR;
        }
        else
        {
            TRACE1 (DEVICE, "ElWriteToInterface: WriteFile failed with error %d",
                dwRetCode);
        }
    }

    TRACE1 (DEVICE, "ElWriteToInterface completed, RetCode = %d", dwRetCode);
    return dwRetCode;
}


// 
// ElHashInterfaceDescToBucket
// 
// Description:
//
// Function called to convert Friendly name of interface into interface hash 
// table index.
//
// Arguments:
//      pwszInterfaceDesc - Friendly name of the interface
//
// Return values:
//      Hash table index between from 0 to INTF_TABLE_BUCKETS-1
//

DWORD
ElHashInterfaceDescToBucket (
        IN WCHAR    *pwszInterfaceDesc
        )
{
    return ((DWORD)((_wtol(pwszInterfaceDesc)) % INTF_TABLE_BUCKETS)); 
}


//
// ElGetITFPointerFromInterfaceDesc
//
// Description:
//
// Function called to convert Friendly name of interface to ITF entry pointer
//
// Arguments:
//      pwszInterfaceDesc - Friendly name of the interface
//
// Return values:
//      Pointer to interface entry in hash table
//

PEAPOL_ITF
ElGetITFPointerFromInterfaceDesc (
        IN WCHAR    *pwszInterfaceDesc 
        )
{
    EAPOL_ITF   *pITFWalker = NULL;
    DWORD       dwIndex;
    INT         i=0;

    TRACE1 (DEVICE, "ElGetITFPointerFromInterfaceDesc: Desc = %ws", pwszInterfaceDesc);
        
    if (pwszInterfaceDesc == NULL)
    {
        return (NULL);
    }

    dwIndex = ElHashInterfaceDescToBucket (pwszInterfaceDesc);

    TRACE1 (DEVICE, "ElGetITFPointerFromItfDesc: Index %d", dwIndex);

    for (pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
            pITFWalker != NULL;
            pITFWalker = pITFWalker->pNext
            )
    {
        if (wcsncmp (pITFWalker->pwszInterfaceDesc, pwszInterfaceDesc, wcslen(pwszInterfaceDesc)) == 0)
        {
            return pITFWalker;
        }
    }

    return (NULL);
}


//
// ElRemoveITFFromTable
// 
// Description:
//
// Function called to remove an interface entry from the interface hash 
// table
//
// Arguments:
//      pITF - Point to the Interface entry in the hash table
//
// Return values:
// 

VOID
ElRemoveITFFromTable (
        IN EAPOL_ITF *pITF
        )
{
    DWORD       dwIndex;
    EAPOL_ITF   *pITFWalker = NULL;
    EAPOL_ITF   *pITFTemp = NULL;

    if (pITF == NULL)
    {
        TRACE0 (EAPOL, "ElRemoveITFFromTable: Deleting NULL ITF, returning");
        return;
    }

    dwIndex = ElHashInterfaceDescToBucket (pITF->pwszInterfaceDesc);
    pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
    pITFTemp = pITFWalker;

    while (pITFTemp != NULL)
    {
        if (wcsncmp (pITFTemp->pwszInterfaceGUID, 
                    pITF->pwszInterfaceGUID, wcslen(pITF->pwszInterfaceGUID)) == 0)
        {
            // Entry is at head of list in table
            if (pITFTemp == g_ITFTable.pITFBuckets[dwIndex].pItf)
            {
                g_ITFTable.pITFBuckets[dwIndex].pItf = pITFTemp->pNext;
            }
            else
            {
                // Entry is inside list in table
                pITFWalker->pNext = pITFTemp->pNext;
            }
        
            break;
        }

        pITFWalker = pITFTemp;
        pITFTemp = pITFWalker->pNext;
    }

    return;
}


//
// ElNdisuioEnumerateInterfaces
// 
// Description:
//
// Function called to enumerate the interfaces on which NDISUIO is bound
//
// Arguments:
//      pItfBuffer - Pointer to buffer which will hold interface details
//      dwAvailableInterfaces - Number of interfaces for which details can
//                      be held in pItfBuffer
//      dwBufferSize - Number of bytes in pItfBuffer
//
// Return values:
// 

DWORD
ElNdisuioEnumerateInterfaces (
        IN OUT  PNDIS_ENUM_INTF     pItfBuffer,
        IN      DWORD               dwAvailableInterfaces,
        IN      DWORD               dwBufferSize
        )
{
    DWORD       dwDesiredAccess;
    DWORD       dwShareMode;
    LPSECURITY_ATTRIBUTES   lpSecurityAttributes = NULL;
    DWORD       dwCreationDistribution;
    DWORD       dwFlagsAndAttributes;
    HANDLE      hTemplateFile;
    HANDLE      hHandle;
    DWORD       dwBytesReturned = 0;
    INT         i;
    CHAR        Buf[1024];
    DWORD       BufLength = sizeof(Buf);
    DWORD       BytesWritten = 0;
    PNDISUIO_QUERY_BINDING pQueryBinding = NULL;
    PCHAR       pTempBuf = NULL;
    DWORD       dwRetCode = NO_ERROR;

    dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
    dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
    dwCreationDistribution = OPEN_EXISTING;
    dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
    hTemplateFile = (HANDLE)INVALID_HANDLE_VALUE;

    TRACE0 (DEVICE, "ElNdisuioEnumerateInterfaces: Opening handle");

    do 
    {

        hHandle = CreateFileA (
                    pNdisuioDevice,
                    dwDesiredAccess,
                    dwShareMode,
                    lpSecurityAttributes,
                    dwCreationDistribution,
                    0,
                    NULL
                    );

        if (hHandle == INVALID_HANDLE_VALUE)
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Failed in CreateFile with error %d", dwRetCode);

            break;
        }

        // Send IOCTL to ensure NDISUIO binds to all relevant interfaces

        if (!DeviceIoControl (
                    hHandle,
                    IOCTL_NDISUIO_BIND_WAIT,
                    NULL,
                    0,
                    NULL,
                    0,
                    &dwBytesReturned,
                    NULL))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Failed in DeviceIoCoontrol NDISUIO_BIND_WAIT with error %d", dwRetCode);
            break;
        }
    
        pQueryBinding = (PNDISUIO_QUERY_BINDING)Buf;

        pTempBuf = (PBYTE)pItfBuffer + dwBufferSize;

        i = 0;
        for (pQueryBinding->BindingIndex = i;
            pQueryBinding->BindingIndex < dwAvailableInterfaces;
            pQueryBinding->BindingIndex = ++i)
        {

            // Query for one interface at a time
            
            if (DeviceIoControl (
                    hHandle,
                    IOCTL_NDISUIO_QUERY_BINDING,
                    pQueryBinding,
                    sizeof(NDISUIO_QUERY_BINDING),
                    Buf,
                    BufLength,
                    &BytesWritten,
                    NULL))
            {
                TRACE3 (DEVICE, "NdisuioEnumerateInterfaces: NDISUIO bound to: (%ld) %ws\n     - %ws\n",
                    pQueryBinding->BindingIndex,
                    (PUCHAR)pQueryBinding + pQueryBinding->DeviceNameOffset,
                    (PUCHAR)pQueryBinding + pQueryBinding->DeviceDescrOffset);

                pTempBuf = pTempBuf - ((pQueryBinding->DeviceNameLength + 7) & 0xfffffff8);

                if (((PBYTE)pTempBuf - (PBYTE)&pItfBuffer->Interface[pItfBuffer->TotalInterfaces]) <= 0)
                {
                    // Going beyond start of buffer, Error
                    TRACE0 (DEVICE, "NdisuioEnumerateInterfaces: DeviceName: Memory being corrupted !!!");
                    dwRetCode = ERROR_INVALID_DATA;
                    break;
                }

                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Buffer = (PWCHAR) pTempBuf;


                memcpy ((BYTE *)(pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Buffer), (BYTE *)((PUCHAR)pQueryBinding + pQueryBinding->DeviceNameOffset), (pQueryBinding->DeviceNameLength ));
                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Length = (SHORT) ( pQueryBinding->DeviceNameLength );
                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.MaximumLength = (SHORT) ( pQueryBinding->DeviceNameLength );

                pTempBuf = pTempBuf - ((pQueryBinding->DeviceDescrLength + 7) & 0xfffffff8);;

                if (((PBYTE)pTempBuf - (PBYTE)&pItfBuffer->Interface[pItfBuffer->TotalInterfaces]) <= 0)
                {
                    // Going beyond start of buffer, Error
                    TRACE0 (DEVICE, "NdisuioEnumerateInterfaces: DeviceDescr: Memory being corrupted !!!");
                    dwRetCode = ERROR_INVALID_DATA;
                    break;
                }

                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Buffer = (PWCHAR) pTempBuf;


                memcpy ((pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Buffer), (PWCHAR)((PUCHAR)pQueryBinding + pQueryBinding->DeviceDescrOffset), (pQueryBinding->DeviceDescrLength ));
                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Length = (SHORT) (pQueryBinding->DeviceDescrLength );
                pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.MaximumLength = (SHORT) (pQueryBinding->DeviceDescrLength );

                pItfBuffer->TotalInterfaces++;

                memset(Buf, 0, BufLength);
            }
            else
            {
                dwRetCode = GetLastError ();
                if (dwRetCode != ERROR_NO_MORE_ITEMS)
                {
                    TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: DeviceIoControl terminated for with IOCTL_NDISUIO_QUERY_BINDING with error %ld",
                            dwRetCode);
                }
                else
                {
                    // Reset error, since it only indicates end-of-list
                    dwRetCode = NO_ERROR;
                    TRACE0 (DEVICE, "ElNdisuioEnumerateInterfaces: DeviceIoControl IOCTL_NDISUIO_QUERY_BINDING has no more entries");
                }
                break;
            }
        }
            
    } while (FALSE);

    // Cleanup 

    if (hHandle != INVALID_HANDLE_VALUE)
    {
        if (!CloseHandle(hHandle))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Error in CloseHandle %d", dwRetCode);
        }
    }
         
    return dwRetCode;
}


//
// ElShutdownInterface
// 
// Description:
//
// Function called to stop EAPOL state machine, close handle to NDISUIO and
//  remove existence of the interface from the module
//
// Arguments:
//      pwszDeviceGUID - Pointer to interface GUID
//
// Return values:
//  NO_ERROR - success
//  non-zero - error
// 

DWORD
ElShutdownInterface (
        IN  WCHAR   *pwszDeviceGUID
        )
{
    WCHAR       *pwszGUID = NULL;
    EAPOL_PCB   *pPCB = NULL;
    EAPOL_ITF   *pITF = NULL;
    HANDLE      hDevice = NULL;
    DWORD       dwRetCode = NO_ERROR;

    do
    {

        TRACE1 (DEVICE, "ElShutdownInterface: Called for interface removal for %ws",
                pwszGUID);

        pwszGUID = MALLOC ( (wcslen (pwszDeviceGUID) + 1) * sizeof(WCHAR));
        if (pwszGUID == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            TRACE0 (DEVICE, "ElShutdownInterface: MALLOC failed for pwszGUID");
            break;
        }

        wcscpy (pwszGUID, pwszDeviceGUID);

        ACQUIRE_WRITE_LOCK (&(g_ITFLock));

        // Check if EAPOL was actually started on this interface
        // Verify by checking existence of corresponding 
        // entry in hash table
    
        ACQUIRE_WRITE_LOCK (&(g_PCBLock));

        if ((pPCB = ElGetPCBPointerFromPortGUID(pwszGUID))
                != NULL)
        {
            RELEASE_WRITE_LOCK (&(g_PCBLock));
            TRACE0 (DEVICE, "ElShutdownInterface: Found PCB entry for interface");

            if ((pITF = ElGetITFPointerFromInterfaceDesc(
                            pPCB->pwszFriendlyName))
                            == NULL)
            {
                TRACE0 (DEVICE, "ElShutdownInterface: Did not find ITF entry when PCB exits, HOW BIZARRE !!!");
            }
    
            if ((dwRetCode = ElDeletePort (
                            pwszGUID, 
                            &hDevice)) != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElShutdownInterface: Error in deleting port for %ws", 
                    pPCB->pwszDeviceGUID);
            }
    
            // Remove interface entry from interface table
            
            if (pITF != NULL)
            {
                ElRemoveITFFromTable(pITF);
                        
                if (pITF->pwszInterfaceDesc)
                {
                    FREE (pITF->pwszInterfaceDesc);
                }
                if (pITF->pwszInterfaceGUID)
                {
                    FREE (pITF->pwszInterfaceGUID);
                }
                if (pITF)
                {
                    FREE (pITF);
                }
            }
    
            // Close the handle to the NDISUIO driver

            if (hDevice != NULL)
            {
                if ((dwRetCode = ElCloseInterfaceHandle (hDevice, pwszGUID)) 
                        != NO_ERROR)
                {
                    TRACE1 (DEVICE, 
                        "ElShutdownInterface: Error in ElCloseInterfaceHandle %d", 
                        dwRetCode);
                }
            }
    
            TRACE1 (DEVICE, "ElShutdownInterface: Port deleted (%ws)", 
                    pwszGUID);
    
        }
        else
        {
            RELEASE_WRITE_LOCK (&(g_PCBLock));

            // Ignore device removal 
            
            TRACE0 (DEVICE, "ElShutdownInterface: ElGetPCBPointerFromPortGUID did not find any matching entry, ignoring interface REMOVAL");
    
        }
    
        RELEASE_WRITE_LOCK (&(g_ITFLock));

    } while (FALSE);

    if (pwszGUID != NULL)
    {
        FREE (pwszGUID);
    }

    return dwRetCode;
}


//
// ElCreateInterfaceEntry
// 
// Description:
//
// Function called to create an entry in the global interface table
//
// Arguments:
//      pwszInterfaceGUID - Pointer to interface GUID
//      pwszInterfaceDescription - Pointer to interface Description
//
// Return values:
//  NO_ERROR - success
//  non-zero - error
// 

DWORD
ElCreateInterfaceEntry (
        IN  WCHAR       *pwszInterfaceGUID,
        IN  WCHAR       *pwszInterfaceDescription
        )
{
    EAPOL_ITF * pNewITF = NULL;
    DWORD       dwIndex = 0;
    DWORD       dwRetCode = NO_ERROR;

    do
    {
        dwIndex = ElHashInterfaceDescToBucket (pwszInterfaceDescription);
                    
        pNewITF = (PEAPOL_ITF) MALLOC (sizeof (EAPOL_ITF));
                    
        if (pNewITF == NULL) 
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pNewITF->pwszInterfaceGUID = 
            (WCHAR *) MALLOC ((wcslen(pwszInterfaceGUID) + 1)*sizeof(WCHAR));
        if (pNewITF->pwszInterfaceGUID == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pNewITF->pwszInterfaceDesc = 
            (WCHAR *) MALLOC ((wcslen(pwszInterfaceDescription) + 1)*sizeof(WCHAR));
        if (pNewITF->pwszInterfaceDesc == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        wcscpy (pNewITF->pwszInterfaceGUID, pwszInterfaceGUID);
        
        wcscpy (pNewITF->pwszInterfaceDesc, pwszInterfaceDescription);

        pNewITF->pNext = g_ITFTable.pITFBuckets[dwIndex].pItf;
        g_ITFTable.pITFBuckets[dwIndex].pItf = pNewITF;


        TRACE3 (DEVICE, "ElCreateInterfaceEntry: Added to hash table GUID= %ws : Desc= %ws at Index=%d",
                pNewITF->pwszInterfaceGUID,
                pNewITF->pwszInterfaceDesc,
                dwIndex
                );
    }
    while (FALSE);

    if (dwRetCode != NO_ERROR)
    {
        if (pNewITF)
        {
            if (pNewITF->pwszInterfaceDesc)
            {
                FREE (pNewITF->pwszInterfaceDesc);
            }
            if (pNewITF->pwszInterfaceGUID)
            {
                FREE (pNewITF->pwszInterfaceGUID);
            }

            FREE (pNewITF);
        }
    }

    return dwRetCode;
}