windows-xp/Source/XPSP1/NT/net/config/netman/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];

// TEST globals
PVOID g_QueryBinding;
PVOID g_TempBuf;
PVOID g_ItfBuffer;
PVOID g_Buf;
DWORD g_ItfBufferSize;
DWORD g_BreakAt;


extern 
VOID 
ElUserLogonDetection (
        PVOID   pvContext
        );


//
// 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 
    {
        // --ft:12/04/00: Initialize locks as the first thing to do. Otherwise, EAPOL registers
        // with WMI and if a notification comes in before getting to initialize the lock this can
        // result in an AV. 
        // Stress failure reported an AV on the following stack:
        // ntdll!RtlpWaitForCriticalSection+0xb1 [z:\nt\base\ntdll\resource.c @ 1631]
        // ntdll!RtlEnterCriticalSection+0x46 [Z:\nt\base\ntdll\i386\critsect.asm @ 157]
        // netman!AcquireWriteLock+0xf [z:\nt\net\config\netman\eapol\service\elsync.c @ 137]
        // netman!ElMediaSenseCallbackWorker+0x15c [z:\nt\net\config\netman\eapol\service\eldeviceio.c @ 937]
        //
        // The CRITICAL_SECTION looked like below:
        //     75e226c4  00000000 00000001 00000000 00000000
        //     75e226d4  00001990 
        // 
        // The (null) DebugInfo shows the object not being initialized successfully.
        //
        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;
        }

        // Register for Media Sense detection of MEDIA_CONNECT and 
        // MEDIA_DISCONNECT of interfaces
        // This is done before anything else, so that no MEDIA events are lost
    
        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 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");
        }

        // 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;
        }
    
        // Watch and update change in global registry parameters

        if (!QueueUserWorkItem (
                    (LPTHREAD_START_ROUTINE)ElWatchGlobalRegistryParams,
                    NULL,
                    WT_EXECUTELONGFUNCTION))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElMediaInit: Critical error: QueueUserWorkItem failed for ElWatchGlobalRegistryParams with error %ld",
                    dwRetCode);
            break;
        }
    
        // Watch changes in EAP config params by checking on
        // ..\EAPOL\Interfaces key

        if (!QueueUserWorkItem (
                    (LPTHREAD_START_ROUTINE)ElWatchEapConfigRegistryParams,
                    NULL,
                    WT_EXECUTELONGFUNCTION 
                    ))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElMediaInit: Critical error: QueueUserWorkItem failed for ElWatchEapConfigRegistryParams with error %ld",
                    dwRetCode);
            break;
        }

        // Use task bar window for getting login notifications

        if (!QueueUserWorkItem (
            (LPTHREAD_START_ROUTINE)ElUserLogonDetection,
            NULL,
            WT_EXECUTELONGFUNCTION))
        {
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "Critical error: QueueUserWorkItem failed for ElUserLogonDetection with error %ld",
                    dwRetCode);
            break;
        }
    
        // 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;
        }
    
        ACQUIRE_WRITE_LOCK (&g_ITFLock)

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

        if ((dwRetCode = ElEnumAndOpenInterfaces (NULL, NULL)) != NO_ERROR)
        {
            TRACE1(INIT, "ElMediaInit: ElEnumAndOpenInterfaces failed with dwRetCode = %d", 
                    dwRetCode );
                    
            RELEASE_WRITE_LOCK (&g_ITFLock);
            break;
        }
        else
        {
            RELEASE_WRITE_LOCK (&g_ITFLock);
            TRACE0(INIT, "ElMediaInit: ElEnumAndOpenInterfaces successful");
        }
        
    } while (FALSE);
        
    if (dwRetCode == NO_ERROR)
    {
        TRACE0(INIT, "ElMediaInit successful");
    }
    else
    {
    }

    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 (
        )
{
    DWORD       dwRetCode = NO_ERROR;

    TRACE0 (INIT, "ElMediaDeInit: Entered");

    // 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 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;
    }

    // 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 0
    if (!FREE(g_ITFTable.pITFBuckets))
    {
        TRACE0 (EAPOL, "ElMediaDeInit: Error in freeing ITF table memory");
        dwRetCode = GetLastError();
    }
#endif
        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));

        // Delete NLA lock

        DELETE_READ_WRITE_LOCK(&(g_NLALock));
    }
    
    TRACE0(INIT, "ElMediaDeInit completed");

    return dwRetCode;
}


//
// 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 = WmiNotificationRegistrationA(
                    (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 = WmiNotificationRegistrationA(
                    (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;

    ZeroMemory (&PnPFilter, sizeof(PnPFilter));

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

    // NOTE:
    // EAPOL service is only working with ANSI strings, hence the ANSI calls

    hDeviceNotification = RegisterDeviceNotificationA(
                                (HANDLE)g_hServiceStatus,
                                &PnPFilter,
                                DEVICE_NOTIFY_SERVICE_HANDLE );

    if (hDeviceNotification == NULL)
    {
        dwRetCode = GetLastError();

        TRACE1 (DEVICE, "ElDeviceNotificationRegister failed with error %ld",
                dwRetCode);
    }

#endif

    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;
    DWORD                           dwRetCode = NO_ERROR;

    TRACE0 (DEVICE, "ElDeviceNotificationHandler entered");

    do
    {

        if (g_hEventTerminateEAPOL == NULL)
        {
            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 + 8)) == 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
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandler: Event NOT for Interface type");
        }

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

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

    return dwRetCode;
}


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

VOID
ElDeviceNotificationHandlerWorker (
        IN  PVOID       pvContext
        )
{
    EAPOL_PCB                       *pPCB = NULL;
    EAPOL_ITF                       *pITF = NULL;
    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;
        }

        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;
            CHAR    *pszGUIDStart = NULL;
            WCHAR   chGUIDSaveLast;
            WCHAR   Buffer1[256];
            CHAR    Buffer2[256];
            UNICODE_STRING      UnicodeGUID;
            ANSI_STRING         AnsiGUID;
        
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Interface arr/rem");

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

            if ((pwszGUIDStart != NULL) && (pwszGUIDEnd != NULL))
            {
                chGUIDSaveLast = *(pwszGUIDEnd+1);
                            
                // Ignore the leading '{' and the trailing '}'
                // in the GUID

                *(pwszGUIDEnd) = L'\0';
                pwszGUIDStart ++;

                UnicodeGUID.Buffer = Buffer1;
                UnicodeGUID.MaximumLength = 256*sizeof(WCHAR);
                RtlInitUnicodeString (&UnicodeGUID, pwszGUIDStart);

                // Will not fail since memory is already allocated for the 
                // conversion

                AnsiGUID.Buffer = Buffer2;
                AnsiGUID.MaximumLength = 256;
                RtlUnicodeStringToAnsiString (&AnsiGUID, 
                        &UnicodeGUID, FALSE);

                AnsiGUID.Buffer[AnsiGUID.Length] = '\0';
                pszGUIDStart = AnsiGUID.Buffer;

                TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: For interface %s",
                        pszGUIDStart);

                // Interface was added

                if (dwEventType == DBT_DEVICEARRIVAL)
                {
                    ACQUIRE_WRITE_LOCK (&g_ITFLock);

                    TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device addition");
        
                    if ((dwRetCode = ElEnumAndOpenInterfaces (NULL, 
                                        pszGUIDStart))
                                        != NO_ERROR)
                    {
                        TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: ElEnumAndOpenInterfaces returned error %ld", 
                            dwRetCode);
                    }
        
                    RELEASE_WRITE_LOCK (&g_ITFLock);
                }
                else
                {
        
                    TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device removal");

                    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(pszGUIDStart))
                            != NULL)
                    {
                        RELEASE_WRITE_LOCK (&(g_PCBLock));
                        TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Found PCB entry for interface");
        
                        if ((pITF = ElGetITFPointerFromInterfaceDesc(
                                        pPCB->pszFriendlyName))
                                        == NULL)
                        {
                            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Did not find ITF entry when PCB exits, HOW BIZARRE !!!");

                        }

                        if ((dwRetCode = ElDeletePort (
                                        pszGUIDStart, 
                                        &hDevice)) != NO_ERROR)
                        {
                            TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: Error in deleting port for %s", 
                                pPCB->pszDeviceGUID);
                        }
        
                        //
                        // Remove interface entry from interface table
                        //
                        
                        if (pITF != NULL)
                        {
                            ElRemoveITFFromTable(pITF);
                                    
                            if (pITF->pszInterfaceDesc)
                            {
                                FREE (pITF->pszInterfaceDesc);
                            }
                            if (pITF->pszInterfaceGUID)
                            {
                                FREE (pITF->pszInterfaceGUID);
                            }
                            if (pITF)
                            {
                                FREE (pITF);
                            }
                        }

                        // Close the handle to the NDISUIO driver

                        if (hDevice != NULL)
                        {
                            if ((dwRetCode = ElCloseInterfaceHandle (hDevice)) 
                                    != NO_ERROR)
                            {
                                TRACE1 (DEVICE, 
                                    "ElDeviceNotificationHandlerWorker: Error in ElCloseInterfaceHandle %d", 
                                    dwRetCode);
                            }
                        }
            
                        TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: Port deleted %s", 
                                pszGUIDStart);

                    }
                    else
                    {
                        RELEASE_WRITE_LOCK (&(g_PCBLock));

                        // Ignore device removal 
                        //
                        TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: ElGetPCBPointerFromPortGUID did not find any matching entry, ignoring DEVICE REMOVAL");
        
                    }

                    RELEASE_WRITE_LOCK (&g_ITFLock);
                }
            }
        }
        else
        {
            TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Event type is is NOT device arr/rem");
        }

    }
    while (FALSE);

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

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

    return;
}


//
// 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;
    DWORD       dwRetCode = NO_ERROR;

    TRACE0 (DEVICE, "ElMediaSenseCallback: Entered");

    do
    {
        if (g_hEventTerminateEAPOL == NULL)
        {
            dwRetCode = NO_ERROR;
            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);
	        ASSERT (0);
        }
    }
    while (FALSE);

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

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

}


//
// 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
//

VOID
ElMediaSenseCallbackWorker (
        IN  PVOID       pvContext
        )
{
    PWNODE_HEADER           pWnodeHeader = (PWNODE_HEADER)pvContext;
    PWNODE_SINGLE_INSTANCE  pWnode   = (PWNODE_SINGLE_INSTANCE)pWnodeHeader;
    LPWSTR                  lpwsName;
    CHAR                    *psName;
    CHAR                    *psDeviceName = NULL;
    CHAR                    psLength;
    USHORT                  cpsLength;
    CHAR                    *psNameEnd;
    LPWSTR                  lpwsDeviceName = NULL;
    HANDLE                  hDevice = NULL;
    UNICODE_STRING          uInterfaceDescription;
    ANSI_STRING             InterfaceDescription;
    PCHAR                   pszInterfaceDescription;
    UCHAR			        Buffer[256];
    CHAR                    *pszInterfaceDesc = NULL;
    DWORD                   dwIndex;
    EAPOL_ITF               *pITF;
    ULONG                   i = 0;
    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;
    }

    psName = (PCHAR)RtlOffsetToPointer(
                                    pWnode,
                                    pWnode->OffsetInstanceName );

    // Get the length of the string
    // Null terminate it 

    cpsLength = (SHORT)( *((SHORT *)psName) );

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

    memcpy ((CHAR *)psDeviceName, (CHAR *)psName+sizeof(SHORT), cpsLength);
    psDeviceName[cpsLength] = '\0';
    RtlInitAnsiString (&InterfaceDescription, psDeviceName);
    InterfaceDescription.Buffer[cpsLength] = '\0';

    TRACE3(DEVICE, "ElMediaSenseCallbackWorker: For interface ANSI %s, true= %s, lengt of block = %d", 
            InterfaceDescription.Buffer, psDeviceName, cpsLength);

    
    pszInterfaceDescription = InterfaceDescription.Buffer;
                                
    TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Interface desc = %s", 
            pszInterfaceDescription);

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

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

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

        ACQUIRE_WRITE_LOCK (&(g_ITFLock))

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

        if ((pITF = ElGetITFPointerFromInterfaceDesc(pszInterfaceDescription))
                != NULL)
        {
            TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Found ITF entry for interface");

#if 0
            if ((dwRetCode = ElDeletePort (pITF->pszInterfaceGUID, &hDevice)) != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Error in deleting port for %s", 
                        pITF->pszInterfaceGUID);
            }

            // Remove interface entry from interface table

            ElRemoveITFFromTable(pITF);

            if (pITF->pszInterfaceDesc)
            {
                FREE (pITF->pszInterfaceDesc);
                pITF->pszInterfaceDesc = NULL;
            }
            if (pITF->pszInterfaceGUID)
            {
                FREE (pITF->pszInterfaceGUID);
                pITF->pszInterfaceGUID = NULL;
            }
            if (pITF)
            {
                FREE (pITF);
                pITF = NULL;
            }

            // Close the handle to the NDISUIO driver

            if ((dwRetCode = ElCloseInterfaceHandle (hDevice)) != NO_ERROR)
            {
                TRACE1 (DEVICE, 
                        "ElMediaSenseCallbackWorker: Error in ElCloseInterfaceHandle %d", 
                        dwRetCode);
            }
            
            TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Port deleted %s", 
                    pszInterfaceDescription);
#endif

            ACQUIRE_WRITE_LOCK (&(g_PCBLock));
            pPCB = ElGetPCBPointerFromPortGUID (pITF->pszInterfaceGUID);
            if (pPCB != NULL)
            {
                ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
                if ((dwRetCode = FSMDisconnected (pPCB)) != NO_ERROR)
                {
                    TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: FSMDisconnected failed with error %ld", 
                        dwRetCode);
                }
                RELEASE_WRITE_LOCK (&(pPCB->rwLock));
            }
            RELEASE_WRITE_LOCK (&(g_PCBLock));

            TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Port marked disconnected %s", 
                    pszInterfaceDescription);

        }
        else
        {
            // Ignore MEDIA DISCONNECT

            TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: ElHashInterfaceDescToBucket did not find any matching entry, ignoring MEDIA_DISCONNECT");
        }

        RELEASE_WRITE_LOCK (&g_ITFLock);

    }
    else
    {

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

            ACQUIRE_WRITE_LOCK (&g_ITFLock)

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

            if ((dwRetCode = ElEnumAndOpenInterfaces (
                            pszInterfaceDescription, NULL))
                != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: ElEnumAndOpenInterfaces returned error %ld", 
                        dwRetCode);
            }
        
            RELEASE_WRITE_LOCK (&g_ITFLock);

        }
    }

    }
    while (FALSE);

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


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

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

    return;
}


// 
// 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 pszDesiredGUID is not NULL, all interfaces are enumerated, but 
// EAPOL will be initialized only on the interface whose GUID matches.
//
// If pszDescription is not NULL, all interfaces are enumerated, but 
// EAPOL will be initialized only on the interface whose description matches.
//
// If pszDesiredGUID and pszDescription 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:
//      pszDesiredDescription - Interface Description on which EAPOL is to 
//                  be started
//      pszDesiredGUID - Interface GUID on which EAPOL is to be started
//
// Return values:
//      NO_ERROR - Success
//      non-zero - Error
//

DWORD
ElEnumAndOpenInterfaces (
        CHAR    *pszDesiredDescription,
        CHAR    *pszDesiredGUID
        )
{
    CHAR				EnumerateBuffer[256];
    PNDIS_ENUM_INTF		Interfaces = NULL;
    BYTE                *pbNdisuioEnumBuffer = NULL;
    DWORD               dwNdisuioEnumBufferSize = 0;
    DWORD				dwNicCardStatus = 0;
    DWORD				dwMediaType = 0;
    HANDLE              hDevice = NULL;
    EAPOL_ITF           *pNewITF = NULL;
    DWORD               dwIndex = 0;
    UCHAR               csCurrMacAddress[6];
    UCHAR               csPermMacAddress[6];
    UCHAR               csOidVendData[16];
    BOOL                fSearchByDescription = FALSE;
    BOOL                fSearchByGUID = FALSE;
    DWORD               dwEapTypeToBeUsed = DEFAULT_EAP_TYPE;
    DWORD               dwEapolEnabled = DEFAULT_EAPOL_STATE;
    CHAR                csDummyBuffer[256];
    UNICODE_STRING      TempUString;
    CHAR                *pszGUIDStart = NULL;
    EAPOL_PCB           *pPCB = NULL;
    BOOL                fPCBExists = FALSE;
    DWORD               dwAvailableInterfaces = 0;
    DWORD				dwRetCode = NO_ERROR;


    TRACE2 (DEVICE, "ElEnumAndOpenInterfaces: DeviceDesc = %s, GUID = %s",
            pszDesiredDescription, pszDesiredGUID);

    if (pszDesiredGUID == NULL)
    {
        if (pszDesiredDescription != NULL)
        {
            fSearchByDescription = TRUE;
        }
    }
    else
    {
        if (pszDesiredDescription != NULL)
        {
            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)) 
    {
        dwRetCode = GetLastError ();
        TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: NdisEnumerateInterfaces failed with error %ld",
                dwRetCode);
        return dwRetCode;
    }

    TRACE3 (DEVICE, "ElEnumAndOpenInterfaces: TotalInterfaces = %ld, AvailInt = %ld, Bytes needed = %ld",
            Interfaces->TotalInterfaces, 
            Interfaces->AvailableInterfaces, 
            Interfaces->BytesNeeded);

    dwAvailableInterfaces = Interfaces->AvailableInterfaces;

    dwNdisuioEnumBufferSize = (Interfaces->BytesNeeded + 7) & ~7;

    if (dwNdisuioEnumBufferSize == 0) {
        TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: MALLOC skipped for zero length pbNdisuioEnumBuffer");
        dwRetCode = NO_ERROR;
        return dwRetCode;
    }

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

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

    Interfaces = (PNDIS_ENUM_INTF)pbNdisuioEnumBuffer;


    // Enumerate all the interfaces present on the machine

    if ((dwRetCode = ElNdisuioEnumerateInterfaces (
                            Interfaces, 
                            dwAvailableInterfaces,
                            4*dwNdisuioEnumBufferSize)) == NO_ERROR)
    {
        ANSI_STRING		InterfaceName;
        ANSI_STRING		InterfaceDescription;
        UNICODE_STRING	UInterfaceName;
        UCHAR			Buffer1[256];
        UCHAR			Buffer2[256];
        WCHAR			Buffer3[256];
        DWORD			i;

        InterfaceName.MaximumLength = 256;
        InterfaceName.Buffer = Buffer1;
        InterfaceDescription.MaximumLength = 256;
        InterfaceDescription.Buffer = Buffer2;

        TRACE1 (DEVICE, "TotalInterfaces=%ld", Interfaces->TotalInterfaces);

        // 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);

            // log
        }

        for (i=0; i < Interfaces->TotalInterfaces; i++)
        {
            if (Interfaces->Interface[i].DeviceName.Buffer != NULL)
            {
                InterfaceName.Length = 0;
                InterfaceName.MaximumLength = 256;
                if (RtlUnicodeStringToAnsiString(&InterfaceName, 
                        &Interfaces->Interface[i].DeviceName, FALSE) != STATUS_SUCCESS)
                {
                    TRACE0 (INIT, "Error in RtlUnicodeStringToAnsiString for DeviceName");
                }

                InterfaceName.Buffer[InterfaceName.Length] = '\0';
            }
            else
            {
                TRACE0(INIT, "NdisEnumerateInterfaces: Device Name was NULL");
                continue;
            }

            TRACE1(INIT, "Device: %s", InterfaceName.Buffer);

            // BUBUG:
            // Should Device Name be retained in Unicode or converted to ANSI

            InterfaceDescription.Length = 0;
            InterfaceDescription.MaximumLength = 256;
            if (RtlUnicodeStringToAnsiString(&InterfaceDescription, 
                    &Interfaces->Interface[i].DeviceDescription, FALSE) != STATUS_SUCCESS)
            {
                    TRACE0 (INIT, "Error in RtlUnicodeStringToAnsiString for DeviceDescription");
            }

            InterfaceDescription.Buffer[InterfaceDescription.Length] = '\0';

            TRACE1(INIT, "Description: %s", InterfaceDescription.Buffer);


            // Create PCB for interface and start EAPOL state machine

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

            if (fSearchByDescription)
            {
                if (strcmp (InterfaceDescription.Buffer,
                            pszDesiredDescription)
                        != 0)
                {
                    // No match, continue with next interface
                    continue;
                }

                TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %s", InterfaceDescription.Buffer);
            }

            if (fSearchByGUID)
            {
                if (strstr (InterfaceName.Buffer,
                            pszDesiredGUID)
                        == NULL)
                {
                    // No match, continue with next interface
                    continue;
                }

                TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %s", InterfaceName.Buffer);
            }

            {
                // Extract GUID-string out of device name

                CHAR    *pszGUIDEnd;
                CHAR    *pszGUID;
                CHAR    chGUIDSaveLast;

                pszGUID = InterfaceName.Buffer;
                pszGUIDStart  = strchr( pszGUID, '{' );
                pszGUIDEnd    = strchr( pszGUID, '}' );

                if (RtlAnsiStringToUnicodeString (
                                                &TempUString,
                                                &InterfaceName,
                                                TRUE))
                {
                    TRACE0 (DEVICE, "Error in RtlAnsiStringToUnicodeString for TempUString");
                }
                    
                // Query MAC address for the interface

                if (!NdisQueryHwAddress (
                                &TempUString,
                                csCurrMacAddress,
                                csPermMacAddress,
                                csOidVendData))
                {
                    RtlFreeUnicodeString (&TempUString);
                    dwRetCode = GetLastError();
                    TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in NdisQueryHwAddress = %d", dwRetCode);
                    dwRetCode = NO_ERROR;
                    continue;
                }

                RtlFreeUnicodeString (&TempUString);
                    
                TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: NdisQueryHwAddress successful");

                if (pszGUIDStart != NULL)
                {
                    chGUIDSaveLast = *(pszGUIDEnd);
                    
                    // Ignore the leading '{' and the trailing '}'
                    // in the GUID

                    *(pszGUIDEnd) = (CHAR)NULL;
                    pszGUIDStart ++;

                }

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

                ACQUIRE_WRITE_LOCK (&g_PCBLock);

                pPCB = ElGetPCBPointerFromPortGUID (pszGUIDStart);

                RELEASE_WRITE_LOCK (&g_PCBLock);

                // Restore interface buffer

                *(pszGUIDEnd) = chGUIDSaveLast;

                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 (
                                    InterfaceName.Buffer,
                                    &hDevice
                                    )) != NO_ERROR)
                    {
                        TRACE1 (INIT, "ElEnumAndOpenInterfaces: ElOpenInterfaceHandle failed with error = %d\n",
                            dwRetCode );
                    }
                }

                *(pszGUIDEnd) = (CHAR)NULL;

            }

            if (dwRetCode != NO_ERROR)
            {
                TRACE0 (INIT, "ElEnumAndOpenInterfaces: Failed to open handle");
                dwRetCode = NO_ERROR;
                continue;
            }
            else
            {
                // Verify if EAPOL is to be started on the interface
                // at all

                if ((dwRetCode = ElGetInterfaceParams (
                                pszGUIDStart,
                                &dwEapTypeToBeUsed,
                                csDummyBuffer,
                                &dwEapolEnabled
                                )) != NO_ERROR)
                {
                    TRACE2 (INIT, "ElEnumAndOpenInterfaces: ElGetInterfaceParams failed with error %ld for interface %s",
                            dwRetCode, pszDesiredGUID);

                    dwEapTypeToBeUsed = DEFAULT_EAP_TYPE;
                    dwEapolEnabled = DEFAULT_EAPOL_STATE;

                    if (dwEapolEnabled)
                    {
                        dwRetCode = NO_ERROR;
                    }
                    else
                    {

                        // Close the handle to the ndisuio driver

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

                        TRACE1 (INIT, "EAPOL will not be started on %s", InterfaceName.Buffer);
                        // Continue with other interfaces
                        continue;
                    }

                }

                if (dwEapolEnabled != EAPOL_ENABLED)
                {
                    TRACE1 (INIT, "EAPOL not to be started on interface %s",
                            pszDesiredGUID);

                    // Close the handle to the ndisuio driver

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

                    // Continue with the next interface

                    dwRetCode = NO_ERROR;
                    continue;
                }
                
                // ISSUE:
                // What MAC address should we pass to CreatePort
                // perm or cur

                // Create EAPOL PCB and start state machine

                if ((dwRetCode = ElCreatePort (
                                hDevice,
                                pszGUIDStart,
                                InterfaceDescription.Buffer,
                                csCurrMacAddress
                                )) != NO_ERROR)
                {
                    TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in CreatePort = %d", dwRetCode);

                    // Close the handle to the ndisuio driver

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

                    // Continue with the next interface

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

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

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

                    
                    // Add entry to Interface hash table

                    dwIndex = ElHashInterfaceDescToBucket (
                        InterfaceDescription.Buffer);
                    pNewITF = (PEAPOL_ITF) 
                        MALLOC (sizeof (EAPOL_ITF));
                    if (pNewITF != NULL) 
                    {
                        pNewITF->pszInterfaceGUID = 
                            (CHAR *) MALLOC (strlen(pszGUIDStart) + 1);
                        if (pNewITF->pszInterfaceGUID != NULL)
                        {
                            memcpy (pNewITF->pszInterfaceGUID,
                                pszGUIDStart,
                                strlen (pszGUIDStart));
                            pNewITF->pszInterfaceGUID[strlen (pszGUIDStart)] = '\0';
                        }
                        pNewITF->pszInterfaceDesc = 
                            (CHAR *) MALLOC (strlen(InterfaceDescription.Buffer) + 1);
                        if (pNewITF->pszInterfaceDesc != NULL)
                        {
                            memcpy (pNewITF->pszInterfaceDesc,
                                InterfaceDescription.Buffer,
                                strlen (InterfaceDescription.Buffer));
                            pNewITF->pszInterfaceDesc[strlen (InterfaceDescription.Buffer)] = '\0';
                        }


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

                        if ( (pNewITF->pszInterfaceGUID == NULL) ||
                                (pNewITF->pszInterfaceDesc == NULL))
                        {
                            ElRemoveITFFromTable (pNewITF); 
                            if (pNewITF->pszInterfaceDesc)
                            {
                                FREE (pNewITF->pszInterfaceDesc);
                            }
                            if (pNewITF->pszInterfaceGUID)
                            {
                                FREE (pNewITF->pszInterfaceGUID);
                            }
                            if (pNewITF)
                            {
                                FREE (pNewITF);
                            }

                            pNewITF = NULL;

                            TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: Error in memory allocation, ITF structure not created");

                        }
                    }

                    // Could not create new interface entry
                    // Delete Port entry created for this GUID

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

                        // Close the handle to the NDISUIO driver

                        if ((dwRetCode = ElCloseInterfaceHandle (
                                        hDevice)) != NO_ERROR)
                        {
                            TRACE1 (DEVICE, 
                                    "ElMediaSenseCallback: Error in ElCloseInterfaceHandle %d", 
                                    dwRetCode);
                            // log
                        }
                    }
                    else
                    {
                        TRACE3 (DEVICE, "ElEnumAndOpenInterfaces: Added to hash table GUID= %s : Desc= %s at Index=%d",
                                pNewITF->pszInterfaceGUID,
                                pNewITF->pszInterfaceDesc,
                                dwIndex
                                );
                        //
                        // Interface Handle created successfully
                        // Notify Zero Config about it
                        //
                    }
                }
            }
        } // 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);
    }

    return dwRetCode;
}


//
// ElGetCardStatus
//
// Function to query the media information for an interface
//
// Input arguments:
//  pDeviceName - Unicode device name
//
// Return values:
//  pdwNetCardStatus - Media state
//  pdwMediaType    - Media type as exposed to NDIS e.g. 802.3
//

DWORD
ElGetCardStatus (  
        PUNICODE_STRING pDeviceName, 
        DWORD           *pdwNetCardStatus,
        DWORD           *pdwMediaType
        )
{
    NIC_STATISTICS 	Stats;
    DWORD		dwNicStatus = 0;
    DWORD		dwRetCode = NO_ERROR;

    Stats.Size = sizeof(NIC_STATISTICS);
    if (NdisQueryStatistics(pDeviceName, &Stats))
    {
        switch (Stats.MediaState)
        {
            case MEDIA_STATE_CONNECTED:
                dwNicStatus = MEDIA_STATE_CONNECTED;
                TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_CONNECTED\n");
                break;
            case MEDIA_STATE_DISCONNECTED:
                dwNicStatus = MEDIA_STATE_DISCONNECTED;
                TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_DISCONNECTED\n");
                break;
            default:
                dwNicStatus = MEDIA_STATE_UNKNOWN;
                TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_STATUS_UNKNOWN\n");
                break;
        }

        switch (Stats.MediaType)
        {
            case NdisMedium802_3:
                TRACE0 (INIT, "ElGetCardStatus: MediaType is 802.3");
                break;
            default:
                TRACE0 (INIT, "ElGetCardStatus: MediaType is NOT *802.3*");
                break;
        }

        *pdwMediaType = Stats.MediaType;
    }
    else
    {
        dwRetCode = GetLastError ();
        TRACE1(INIT, "ElGetCardStatus: NdisQueryStatistics failed with error %d\n", dwRetCode);
    }

    *pdwNetCardStatus = dwNicStatus;

    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  CHAR        *pszDeviceName,
        OUT HANDLE      *phDevice
        )
{
    DWORD   dwDesiredAccess;
    DWORD   dwShareMode;
    LPSECURITY_ATTRIBUTES   lpSecurityAttributes = NULL;
    DWORD   dwCreationDistribution;
    DWORD   dwFlagsAndAttributes;
    HANDLE  hTemplateFile;
    HANDLE  hHandle;
    DWORD   dwRetCode = NO_ERROR;
    WCHAR   wNdisDeviceName[MAX_NDIS_DEVICE_NAME_LEN];
    INT     wNameLength;
    INT     NameLength = strlen(pszDeviceName);
    DWORD   dwBytesReturned;
    USHORT  wEthernetType=0x8081;
    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 %s", pszDeviceName);

    do 
    {

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

        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;
        }
    
        // 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
                ))
        {
            *phDevice = NULL;
            dwRetCode = GetLastError();
            TRACE1 (DEVICE, "ElOpenInterfaceHandle: Error in BindIoCompletionCallBac %d", dwRetCode);
            break;
        }
        
    } while (FALSE);

    // Cleanup if there is error

    if (dwRetCode != NO_ERROR)
    {
        if (hHandle != INVALID_HANDLE_VALUE)
        {
            if (!CloseHandle(hHandle))
            {
                dwRetCode = GetLastError();
                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
        )
{
    DWORD   dwRetCode = NO_ERROR;

    TRACE0 (DEVICE, "ElCloseInterfaceHandle entered");

    if (!CloseHandle(hDevice))
    {
        dwRetCode = GetLastError();
        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, dwRetCode = %d", dwRetCode);
    return dwRetCode;
}


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

DWORD
ElHashInterfaceDescToBucket (
        IN CHAR *pszInterfaceDesc
        )
{
    return ((DWORD)((atol(pszInterfaceDesc)) % INTF_TABLE_BUCKETS)); 
}


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

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

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

    dwIndex = ElHashInterfaceDescToBucket (pszInterfaceDesc);

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

    for (pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
            pITFWalker != NULL;
            pITFWalker = pITFWalker->pNext
            )
    {
        if (strncmp (pITFWalker->pszInterfaceDesc, pszInterfaceDesc, strlen(pszInterfaceDesc)) == 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->pszInterfaceDesc);
    pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
    pITFTemp = pITFWalker;

    while (pITFTemp != NULL)
    {
        if (strncmp (pITFTemp->pszInterfaceGUID, 
                    pITF->pszInterfaceGUID, strlen(pITF->pszInterfaceGUID)) == 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:
//      pBuffer - 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)
        {

Try_Again:

            g_QueryBinding = NULL;
            g_TempBuf = NULL;
            g_ItfBuffer = NULL;
            g_Buf = NULL;
            g_ItfBufferSize = 0;
            g_BreakAt = 1;
            
            // 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: %2d. %ws\n     - %ws\n",
                    pQueryBinding->BindingIndex,
                    (PUCHAR)pQueryBinding + pQueryBinding->DeviceNameOffset,
                    (PUCHAR)pQueryBinding + pQueryBinding->DeviceDescrOffset);

                g_QueryBinding = (PVOID)pQueryBinding;
                g_TempBuf = (PVOID)pTempBuf;
                g_ItfBuffer = (PVOID)pItfBuffer;
                g_ItfBufferSize = dwBufferSize;
                g_Buf = (PVOID)Buf;
                g_BreakAt = 1;

                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 !!!");
                    DebugBreak ();

                    goto Try_Again;
                }

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


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

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

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

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


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

                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);
        }
    }
         
    TRACE2 (DEVICE, "ElNdisuioEnumerateInterfaces: Opened handle %p with dwRetCode %d", 
            hHandle, 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:
//      pszGUID - Pointer to interface GUID
//
// Return values:
//  NO_ERROR - success
//  non-zero - error
// 

DWORD
ElShutdownInterface (
        IN      CHAR               *pszGUID
        )
{
    EAPOL_PCB   *pPCB = NULL;
    EAPOL_ITF   *pITF = NULL;
    HANDLE      hDevice = NULL;
    DWORD       dwRetCode = NO_ERROR;

    do
    {

        TRACE0(DEVICE, "ElShutdownInterface: Called for interface removal");

        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(pszGUID))
                != NULL)
        {
            RELEASE_WRITE_LOCK (&(g_PCBLock));
            TRACE0 (DEVICE, "ElShutdownInterface: Found PCB entry for interface");
    
            if ((pITF = ElGetITFPointerFromInterfaceDesc(
                            pPCB->pszFriendlyName))
                            == NULL)
            {
                TRACE0 (DEVICE, "ElShutdownInterface: Did not find ITF entry when PCB exits, HOW BIZARRE !!!");
            }
    
            if ((dwRetCode = ElDeletePort (
                            pszGUID, 
                            &hDevice)) != NO_ERROR)
            {
                TRACE1 (DEVICE, "ElShutdownInterface: Error in deleting port for %s", 
                    pPCB->pszDeviceGUID);
            }
    
            // Remove interface entry from interface table
            
            if (pITF != NULL)
            {
                ElRemoveITFFromTable(pITF);
                        
                if (pITF->pszInterfaceDesc)
                {
                    FREE (pITF->pszInterfaceDesc);
                }
                if (pITF->pszInterfaceGUID)
                {
                    FREE (pITF->pszInterfaceGUID);
                }
                if (pITF)
                {
                    FREE (pITF);
                }
            }
    
            // Close the handle to the NDISUIO driver

            if (hDevice != NULL)
            {
                if ((dwRetCode = ElCloseInterfaceHandle (hDevice)) 
                        != NO_ERROR)
                {
                    TRACE1 (DEVICE, 
                        "ElShutdownInterface: Error in ElCloseInterfaceHandle %d", 
                        dwRetCode);
                }
            }
    
            TRACE1 (DEVICE, "ElShutdownInterface: Port deleted %s", 
                    pszGUID);
    
        }
        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);

    return dwRetCode;
}