windows-xp/Source/XPSP1/NT/net/config/netman/eapol/service/elprotocol.c

/*++

Copyright (c) 1999, Microsoft Corporation

Module Name:

    elprotocol.c

Abstract:
    This module implements functions related to EAPOL 
    protocol


Revision History:

    sachins, Apr 30 2000, Created

--*/

#include "pcheapol.h"
#pragma hdrstop

#define EAPOL_SERVICE

#ifndef EAPOL_SERVICE

HRESULT 
EAPOLMANAuthenticationStarted (
        REFGUID InterfaceId
);

HRESULT 
EAPOLMANAuthenticationSucceeded (
        REFGUID InterfaceId
);

HRESULT 
EAPOLMANAuthenticationFailed ( 
        REFGUID InterfaceId,
        DWORD dwType
);

HRESULT EAPOLMANNotification(
        REFGUID InterfaceId,
        LPWSTR szwNotificationMessage,
        DWORD dwType
);

#endif

//
// ElProcessReceivedPacket
//
// Description:
//
//      Function called to process data received from the NDISUIO driver.
//      The EAPOL packet is extracted and further processing is done.
//
//
// Arguments:
//      pvContext - Context buffer which is a pointer to EAPOL_BUFFER structure
//
// Return Values:
//

VOID 
ElProcessReceivedPacket (
        IN  PVOID   pvContext
        )
{
    EAPOL_PCB       *pPCB = NULL;
    EAPOL_BUFFER    *pEapolBuffer = NULL;
    DWORD           dwLength = 0;
    ETH_HEADER      *pEthHdr = NULL;
    EAPOL_PACKET    *pEapolPkt = NULL;
    EAPOL_PACKET_D8 *pEapolPktD8 = NULL;
    BOOLEAN         fRemoteEnd8021XD8 = FALSE;
    PPP_EAP_PACKET  *pEapPkt = NULL;
    BYTE            *pBuffer;
    BOOLEAN         ReqId = FALSE;      // EAPOL state machine local variables
    BOOLEAN         ReqAuth = FALSE;
    BOOLEAN         EapSuccess = FALSE;
    BOOLEAN         EapFail = FALSE;
    BOOLEAN         RxKey = FALSE;
    GUID            DeviceGuid;
    EAPOL_PACKET_D8_D7      DummyHeader;
    DWORD           dwRetCode = NO_ERROR;


    if (pvContext == NULL)
    {
        TRACE0 (EAPOL, "ProcessReceivedPacket: Critical error, Context is NULL");
        return;
    }

    pEapolBuffer = (EAPOL_BUFFER *)pvContext;
    pPCB = (EAPOL_PCB *)pEapolBuffer->pvContext;
    dwLength = pEapolBuffer->dwBytesTransferred;
    pBuffer = (BYTE *)pEapolBuffer->pBuffer;

    TRACE1 (EAPOL, "ProcessReceivedPacket entered, length = %ld", dwLength);

    do 
    {
        // The Port was verified to be active before the workitem
        // was queued. But do a double-check

        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (EAPOL, "ProcessReceivedPacket: Port %s not active",
                    pPCB->pszDeviceGUID);
            RELEASE_WRITE_LOCK (&(pPCB->rwLock));
            FREE (pEapolBuffer);
            break;
        }
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));

        // Validate packet length
        // Should be atleast ETH_HEADER and first 4 required bytes of 
        // EAPOL_PACKET
        if (dwLength < (sizeof(ETH_HEADER) + 4))
        {
            TRACE2 (EAPOL, "ProcessReceivedPacket: Packet length %ld is less than minimum required %d. Ignoring packet",
                    dwLength, (sizeof(ETH_HEADER) + 4));
            FREE (pEapolBuffer);
            dwRetCode =  ERROR_INVALID_PACKET_LENGTH_OR_ID;
            break;
        }

        // Validate Destination MAC Address
        // Compare with MAC address got during MEDIA_CONNECT

#if 0
        pEthHdr = (ETH_HEADER *)pBuffer;
        if ((memcmp ((BYTE *)pEthHdr->bSrcAddr, 
                        (BYTE *)pPCB->bDestMacAddr, 
                        SIZE_MAC_ADDR)) != 0)
        {
            TRACE2 (EAPOL, "ProcessReceivedPacket: Dest MAC address %s does not match PAE address %s. Ignoring packet",
                    pEthHdr->SrcAddr,
                    pPCB->bDestMacAddr);
            FREE (pEapolBuffer);
            dwRetCode = ERROR_INVALID_ADDRESS;
            break;
        }
#endif

        // Verify if the packet contains a 802.1P tag. If so, skip the 4 bytes
        // after the src+dest mac addresses

        if ((WireToHostFormat16(pBuffer + sizeof(ETH_HEADER)) == EAPOL_8021P_TAG_TYPE))
        {
            pEapolPkt = (EAPOL_PACKET *)(pBuffer + sizeof(ETH_HEADER) + 4);
        }
        else
        {
            pEapolPkt = (EAPOL_PACKET *)(pBuffer + sizeof(ETH_HEADER));
        }

        // Validate Ethernet type in the incoming packet
        // It should be the same as the one defined for the
        // current port

        if (memcmp ((BYTE *)pEapolPkt->EthernetType, (BYTE *)pPCB->bEtherType,
                        SIZE_ETHERNET_TYPE) != 0)
        {
            TRACE2 (EAPOL, "ProcessReceivedPacket: Packet PAE type %s does not match expected type %s. Ignoring packet",
                    pEapolPkt->EthernetType,
                    pPCB->bEtherType);
            FREE (pEapolBuffer);
            dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
            break;
        }

        // EAPOL packet type should be valid
        if ((pEapolPkt->PacketType != EAP_Packet) &&
                (pEapolPkt->PacketType != EAPOL_Start) &&
                (pEapolPkt->PacketType != EAPOL_Logoff) &&
                (pEapolPkt->PacketType != EAPOL_Key))
        {
            TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid EAPOL packet type %d. Ignoring packet",
                    pEapolPkt->PacketType);
            FREE (pEapolBuffer);
            dwRetCode = ERROR_INVALID_PACKET;
            break;
        }


        // Determine the value of local EAPOL state variables
        if (pEapolPkt->PacketType == EAP_Packet)
        {
            TRACE0 (EAPOL, "ProcessReceivedPacket: EAP_Packet");
            // Validate length of packet for EAP
            // Should be atleast (ETH_HEADER+EAPOL_PACKET)
            if (dwLength < (sizeof (ETH_HEADER) + sizeof (EAPOL_PACKET)))
            {
                TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid length of EAP packet %d. Ignoring packet",
                        dwLength);
                FREE (pEapolBuffer);
                dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
                break;
            }


            // Determine if the packet is draft 8 or not

            pEapolPktD8 = (EAPOL_PACKET_D8 *)pEapolPkt;

            pEapPkt = (PPP_EAP_PACKET *)pEapolPktD8->PacketBody;


            switch (WireToHostFormat16(pEapolPktD8->AuthResultCode))
            {
                case AUTH_Continuing:
                    if (pEapPkt->Code == EAPCODE_Request)
                    {
                        fRemoteEnd8021XD8 = TRUE;
                    }
                    break;

                case AUTH_Authorized:
                    if (pEapPkt->Code ==  EAPCODE_Success)

                    {
                        fRemoteEnd8021XD8 = TRUE;
                    }
                    break;

                case AUTH_Unauthorized:
                    if ((pEapPkt->Code ==  EAPCODE_Failure) ||
                        (pEapPkt->Code ==  EAPCODE_Success))
                    {
                        fRemoteEnd8021XD8 = TRUE;
                    }
                    break;
            }

            if (fRemoteEnd8021XD8 && (WireToHostFormat16(pEapolPktD8->PacketBodyLength) != 0))
            {
                TRACE0 (EAPOL, "ProcessReceivedPacket: Packet received DRAFT 8 format");
                pPCB->fRemoteEnd8021XD8 = TRUE;

                memcpy (DummyHeader.AuthResultCode, pEapolPktD8->AuthResultCode,
                        2);
                memcpy (DummyHeader.EthernetType, pEapolPktD8->EthernetType,
                        2);
                DummyHeader.ProtocolVersion = pEapolPktD8->ProtocolVersion;
                DummyHeader.PacketType = pEapolPktD8->PacketType;

                memcpy ((BYTE *)pEapolPktD8, (BYTE *)&DummyHeader, 6);

                pEapolPkt = (EAPOL_PACKET *)((BYTE *)pEapolPktD8 + 2);
            }
            else
            {
                pPCB->fRemoteEnd8021XD8 = FALSE;
                TRACE0 (EAPOL, "ProcessReceivedPacket: Packet received PRE-DRAFT 8 format");
            }

            pEapPkt = (PPP_EAP_PACKET *)pEapolPkt->PacketBody;

            if (pEapPkt->Code == EAPCODE_Request)
            {
                // Validate length of packet for EAP-Request packet
                // Should be atleast (ETH_HEADER+EAPOL_PACKET-1+PPP_EAP_PACKET)
                if (dwLength < (sizeof (ETH_HEADER) + sizeof(EAPOL_PACKET)-1
                            + sizeof (PPP_EAP_PACKET)))
                {
                    TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid length of EAP Request packet %d. Ignoring packet",
                            dwLength);
                    FREE (pEapolBuffer);
                    dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
                    break;
                }
                if (pEapPkt->Data[0] == EAPTYPE_Identity)
                {
                    pPCB->fIsRemoteEndEAPOLAware = TRUE;
                    ReqId = TRUE;
                }
                else
                {
                    ReqAuth = TRUE;
                }
            }
            else if (pEapPkt->Code ==  EAPCODE_Success)
            {
                EapSuccess = TRUE;
            }
            else if (pEapPkt->Code == EAPCODE_Failure)
            {
                EapFail = TRUE;
            }
            else
            {
                // Invalid type
                TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid EAP packet type %d. Ignoring packet",
                        pEapPkt->Code);
                FREE (pEapolBuffer);
                dwRetCode = ERROR_INVALID_PACKET;
                break;
            }
        }
        else
        {
            TRACE0 (EAPOL, "ProcessReceivedPacket: != EAP_Packet");
            if (pEapolPkt->PacketType == EAPOL_Key)
            {
                TRACE0 (EAPOL, "ProcessReceivedPacket: == EAPOL_Key");
                RxKey = TRUE;
            
                // Determine if the packet is draft 8 or not

                pEapolPktD8 = (EAPOL_PACKET_D8 *)pEapolPkt;

                // In pre-draft 8, PacketBodyLength cannot be '0'
                // If it is zero, it is draft 8 packet format

                if (WireToHostFormat16(pEapolPktD8->AuthResultCode)
                        == AUTH_Continuing)
                {
                    pPCB->fRemoteEnd8021XD8 = TRUE;

                    memcpy (DummyHeader.AuthResultCode, 
                            pEapolPktD8->AuthResultCode,
                            2);

                    memcpy (DummyHeader.EthernetType, 
                            pEapolPktD8->EthernetType,
                            2);

                    DummyHeader.ProtocolVersion = pEapolPktD8->ProtocolVersion;
                    DummyHeader.PacketType = pEapolPktD8->PacketType;

                    memcpy ((BYTE *)pEapolPktD8, (BYTE *)&DummyHeader, 6);

                    pEapolPkt = (EAPOL_PACKET *)((BYTE *)pEapolPktD8 + 2);
                }
                else
                {
                    pPCB->fRemoteEnd8021XD8 = FALSE;
                    TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOL_Key Packet received PRE-DRAFT 8 format");
                }
            }
        }

        //
        // NOTE:
        // Should we check values of EAP type
        //

        // Checking value of PCB fields now
        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        switch (pPCB->State)
        {
            // ReqId, ReqAuth, EapSuccess, EapFail, RxKey are inherently 
            // mutually exclusive
            // No checks will be made to verify this
            // Also, assumption is being made that in any state, maximum 
            // one timer may be active on the port.

            case EAPOLSTATE_LOGOFF:
                // Only a User Logon event can get the port out of
                // LOGOFF state
                TRACE0 (EAPOL, "ProcessReceivedPacket: LOGOFF state, Ignoing packet");
                break;

            case EAPOLSTATE_DISCONNECTED:
                // Only a Media Connect event can get the port out of
                // DISCONNECTED state
                TRACE0 (EAPOL, "ProcessReceivedPacket: DISCONNECTED state, Ignoing packet");
                break;

            case EAPOLSTATE_CONNECTING:
                TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_CONNECTING");
                if (ReqId | EapSuccess | EapFail)
                {
                    // Deactivate current timer
                    RESTART_TIMER (pPCB->hTimer,
                            INFINITE_SECONDS, 
                            "PCB",
                            &dwRetCode);
                    if (dwRetCode != NO_ERROR)
                    {
                        break;
                    }
                }

                if (EapSuccess)
                {
                    if ((dwRetCode = ElProcessEapSuccess (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                else
                if (EapFail)
                {
                    if ((dwRetCode = ElProcessEapFail (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                else
                if (ReqId)
                {
                    if ((dwRetCode = FSMAcquired (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }


                break;

            case EAPOLSTATE_ACQUIRED:
                TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_ACQUIRED");
                if (ReqId | ReqAuth | EapSuccess | EapFail)
                {
                    // Deactivate current timer
                    RESTART_TIMER (pPCB->hTimer,
                            INFINITE_SECONDS,  
                            "PCB",
                            &dwRetCode);
                    if (dwRetCode != NO_ERROR)
                    {
                        break;
                    }
                }

                if (EapSuccess)
                {
                    if ((dwRetCode = ElProcessEapSuccess (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                else
                if (EapFail)
                {
                    if ((dwRetCode = ElProcessEapFail (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                else
                if (ReqId)
                {
                    if ((dwRetCode = FSMAcquired (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                else
                if (ReqAuth)
                {
                    if ((dwRetCode = FSMAuthenticating (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }

                break;

            case EAPOLSTATE_AUTHENTICATING:
                TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_AUTHENTICATING");
                // Common timer deletion
                if (ReqAuth | ReqId | EapSuccess | EapFail)
                {
                    // Deactivate current timer
                    RESTART_TIMER (pPCB->hTimer,
                            INFINITE_SECONDS,   
                            "PCB",
                            &dwRetCode);
                    if (dwRetCode != NO_ERROR)
                    {
                        break;
                    }

                    if (ReqId)
                    {
                        if ((dwRetCode = FSMAcquired (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                        {
                            break;
                        }
                    }
                    else
                    {
                        if ((dwRetCode = FSMAuthenticating (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                        {
                            break;
                        }
                    }
                }

                // Continue further processing

                if (EapSuccess | EapFail)
                {
                    // Auth timer will have restarted in FSMAuthenticating
                    // Deactivate the timer
                    RESTART_TIMER (pPCB->hTimer,
                            INFINITE_SECONDS,
                            "PCB",
                            &dwRetCode);
                    if (dwRetCode != NO_ERROR)
                    {
                        break;
                    }

                    // If the packet received was a EAP-Success, go into 
                    // AUTHENTICATED state
                    if (EapSuccess)
                    {
                        if ((dwRetCode = ElProcessEapSuccess (pPCB,
                                                    pEapolPkt)) != NO_ERROR)
                        {
                            break;
                        }
    
                    }
                    else
                    // If the packet received was a EAP-Failure, go into 
                    // HELD state
                    if (EapFail)
                    {
                        if ((dwRetCode = ElProcessEapFail (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                        {
                            break;
                        }
                    }
                }

                break;

            case EAPOLSTATE_HELD:
                TRACE0 (EAPOL, "ProcessReceivedPacket: HELD state, Ignoring packet");
                if (ReqId)
                {
                    // Deactivate current timer
                    RESTART_TIMER (pPCB->hTimer,
                            INFINITE_SECONDS,
                            "PCB",
                            &dwRetCode);
                    if (dwRetCode != NO_ERROR)
                    {
                        break;
                    }
                    if ((dwRetCode = FSMAcquired (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                break;

            case EAPOLSTATE_AUTHENTICATED:
                TRACE0 (EAPOL, "ProcessReceivedPacket: STATE_AUTHENTICATED");
                if (ReqId)
                {
                    if ((dwRetCode = FSMAcquired (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }

                }
                else
                if (RxKey)
                {
                    if ((dwRetCode = FSMRxKey (pPCB,
                                                pEapolPkt)) != NO_ERROR)
                    {
                        break;
                    }
                }
                break;

            default:
                TRACE0 (EAPOL, "ProcessReceivedPacket: Critical Error. Invalid state, Ignoring packet");
                break;
        }

        // Only packet passing through switch statement will be freed here
        FREE (pEapolBuffer);

        RELEASE_WRITE_LOCK (&(pPCB->rwLock));

    } while (FALSE);

    
    // Post a new read request, ignoring errors
            
    ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
    if (!EAPOL_PORT_ACTIVE(pPCB))
    {
        TRACE1 (EAPOL, "ProcessReceivedPacket: Port %s not active, not reposting read request",
                pPCB->pszDeviceGUID);
        // Port is not active, release Context buffer
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
    }
    else
    {
        TRACE1 (EAPOL, "ProcessReceivedPacket: Reposting buffer on port %s",
                pPCB->pszDeviceGUID);
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
        
        // ElReadFromPort creates a new context buffer, adds a ref count,
        // and posts the read request
        if ((dwRetCode = ElReadFromPort (
                                        pPCB,
                                        NULL,
                                        0
                                        )) != NO_ERROR)
        {
            TRACE1 (EAPOL, "ProcessReceivedPacket: Critical error: ElReadFromPort error %d",
                    dwRetCode);
            // LOG
        }
    }
    
    // Dereference ref count held for the read that was just processed
    EAPOL_DEREFERENCE_PORT(pPCB);
    TRACE2 (EAPOL, "ProcessReceivedPacket: pPCB= %p, RefCnt = %ld", 
            pPCB, pPCB->dwRefCount);

    TRACE0 (EAPOL, "ProcessReceivedPacket exit");

    return;
}


// 
// FSMDisconnected
//
// Description:
//      Function called when media disconnect occurs
//
// Arguments:
//      pPCB - Pointer to PCB for the port on which media disconnect occurs
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMDisconnected (
        IN  EAPOL_PCB   *pPCB
        )
{
    DWORD           dwRetCode   = NO_ERROR;

    TRACE1 (EAPOL, "FSMDisconnected entered for port %s", pPCB->pszFriendlyName);

    do 
    {

    } while (FALSE);

    TRACE1 (EAPOL, "Setting state DISCONNECTED for port %s", pPCB->pszFriendlyName);

    pPCB->State = EAPOLSTATE_DISCONNECTED;

    // Free Identity buffer

    if (pPCB->pszIdentity != NULL)
    {
        FREE (pPCB->pszIdentity);
        pPCB->pszIdentity = NULL;
    }

    // Free Password buffer

    if (pPCB->pszPassword != NULL)
    {
        FREE (pPCB->pszPassword);
        pPCB->pszPassword = NULL;
    }

    // Free user-specific data in the PCB

    if (pPCB->pCustomAuthUserData != NULL)
    {
        FREE (pPCB->pCustomAuthUserData);
        pPCB->pCustomAuthUserData = NULL;
    }

    // Free connection data, though it is common to all users

    if (pPCB->pCustomAuthConnData != NULL)
    {
        FREE (pPCB->pCustomAuthConnData);
        pPCB->pCustomAuthConnData = NULL;
    }

    // Free SSID

    if (pPCB->pszSSID != NULL)
    {
        FREE (pPCB->pszSSID);
        pPCB->pszSSID = NULL;
    }

    pPCB->fGotUserIdentity = FALSE;

    TRACE1 (EAPOL, "FSMDisconnected completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


// 
// FSMLogoff
//
// Description:
//      Function called to send out EAPOL_Logoff packet. Usually triggered by
//      user logging off.
//
// Arguments:
//      pPCB - Pointer to PCB for the port on which logoff packet is to be
//              sent out
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMLogoff (
        IN  EAPOL_PCB   *pPCB
        )
{
    EAPOL_PACKET    *pEapolPkt  = NULL;
    DWORD           dwRetCode   = NO_ERROR;

    TRACE1 (EAPOL, "FSMLogoff entered for port %s", pPCB->pszFriendlyName);

    do 
    {
        // Allocate new buffer
        pEapolPkt = (EAPOL_PACKET *) MALLOC (sizeof (EAPOL_PACKET));
        if (pEapolPkt == NULL)
        {
            TRACE0 (EAPOL, "FSMLogoff: Error in allocating memory for EAPOL packet");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        // Fill in fields

        memcpy ((BYTE *)pEapolPkt->EthernetType, 
                (BYTE *)pPCB->bEtherType, 
                SIZE_ETHERNET_TYPE);
        pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
        pEapolPkt->PacketType = EAPOL_Logoff;
        HostToWireFormat16 ((WORD)0, (BYTE *)pEapolPkt->PacketBodyLength);

        // Send packet out on the port
        dwRetCode = ElWriteToPort (pPCB,
                                    (CHAR *)pEapolPkt,
                                    sizeof (EAPOL_PACKET));
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMLogoff: Error in writing Logoff pkt to port %ld",
                    dwRetCode);

            break;
        }

        // Mark that EAPOL_Logoff was sent out on the port
        pPCB->dwLogoffSent = 1;

    } while (FALSE);

    TRACE1 (EAPOL, "Setting state LOGOFF for port %s", pPCB->pszFriendlyName);

    pPCB->State = EAPOLSTATE_LOGOFF;

    // Free Identity buffer

    if (pPCB->pszIdentity != NULL)
    {
        FREE (pPCB->pszIdentity);
        pPCB->pszIdentity = NULL;
    }

    // Free Password buffer

    if (pPCB->pszPassword != NULL)
    {
        FREE (pPCB->pszPassword);
        pPCB->pszPassword = NULL;
    }

    // Free user-specific data in the PCB

    if (pPCB->pCustomAuthUserData != NULL)
    {
        FREE (pPCB->pCustomAuthUserData);
        pPCB->pCustomAuthUserData = NULL;
    }

    // Free connection data, though it is common to all users

    if (pPCB->pCustomAuthConnData != NULL)
    {
        FREE (pPCB->pCustomAuthConnData);
        pPCB->pCustomAuthConnData = NULL;
    }

    // Free SSID

    if (pPCB->pszSSID != NULL)
    {
        FREE (pPCB->pszSSID);
        pPCB->pszSSID = NULL;
    }

    pPCB->fGotUserIdentity = FALSE;

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

    TRACE1 (EAPOL, "FSMLogoff completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// FSMConnecting
//
// Description:
//
// Funtion called to send out EAPOL_Start packet. If MaxStart EAPOL_Start 
// packets have been sent out, State Machine moves to Authenticated state
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which Start packet is 
//      to be sent out
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMConnecting (
        IN  EAPOL_PCB   *pPCB
        )
{
    EAPOL_PACKET    *pEapolPkt = NULL;
    DWORD           dwStartInterval = 0;               
    GUID            DeviceGuid;
    DWORD           dwRetCode = NO_ERROR;

    TRACE1 (EAPOL, "FSMConnecting entered for port %s", pPCB->pszFriendlyName);

#ifndef EAPOL_SERVICE

    ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
    (VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);

#endif

    do 
    {
        if (pPCB->State == EAPOLSTATE_CONNECTING)
        {
            // If PCB->State was Connecting earlier, increment ulStartCount 
            // else set ulStartCount to zero
    
            // Did not receive Req/Id
            if ((++(pPCB->ulStartCount)) > pPCB->EapolConfig.dwmaxStart)
            {
                // Deactivate start timer
                RESTART_TIMER (pPCB->hTimer,
                        INFINITE_SECONDS,
                        "PCB",
                        &dwRetCode);
                if (dwRetCode != NO_ERROR)
                {
                    break;
                }

                TRACE0 (EAPOL, "FSMConnecting: Sent out maxStart with no response, Setting AUTHENTICATED state");

                // Sent out enough EAPOL_Starts
                // Go into authenticated state
                if ((dwRetCode = FSMAuthenticated (pPCB,
                                            pEapolPkt)) != NO_ERROR)
                {
                    TRACE1 (EAPOL, "FSMConnecting: Error in FSMAuthenticated %ld",
                            dwRetCode);
                    break;
                }

#ifndef EAPOL_SERVICE

                // Display change of status using sys tray balloon
                // on interface icon
                ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
                (VOID)EAPOLMANAuthenticationSucceeded (&DeviceGuid);

#endif

                // No need to send out more EAPOL_Start packets

                // Reset start packet count
                pPCB->ulStartCount = 0;
                pPCB->fIsRemoteEndEAPOLAware = FALSE;
                break;
            }
        }
        else
        {
            pPCB->ulStartCount++;
        }
            
        // If user is not logged in, send out EAPOL_Start packets
        // at intervals of 1 second each. This is used to detect if the
        // interface is on a secure network or not. 
        // If user is logged in, use the configured value for the 
        // StartPeriod as the interval
        //if (!pPCB->fUserLoggedIn)

        if (!g_fUserLoggedOn)
        {
            dwStartInterval = EAPOL_INIT_START_PERIOD; // 1 second
        }
        else
        {
            dwStartInterval = pPCB->EapolConfig.dwstartPeriod;
        }

        // Restart timer with startPeriod
        // Even if error occurs, timeout will happen
        // Else, we won't be able to get out of connecting state
        RESTART_TIMER (pPCB->hTimer,
                dwStartInterval,
                "PCB",
                &dwRetCode);
            
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMConnecting: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        // Send out EAPOL_Start
        // Allocate new buffer
        pEapolPkt = (EAPOL_PACKET *) MALLOC (sizeof(EAPOL_PACKET));
        if (pEapolPkt == NULL)
        {
            TRACE0 (EAPOL, "FSMConnecting: Error in allocating memory for EAPOL packet");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        // ISSUE:
        // Does Authenticator side also ignore data beyond PacketType
        // as the supplicant side does?

        memcpy ((BYTE *)pEapolPkt->EthernetType, 
                (BYTE *)pPCB->bEtherType, 
                SIZE_ETHERNET_TYPE);
        pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
        pEapolPkt->PacketType = EAPOL_Start;
        HostToWireFormat16 ((WORD)0, (BYTE *)pEapolPkt->PacketBodyLength);

        // Send packet out on the port
        dwRetCode = ElWriteToPort (pPCB,
                                    (CHAR *)pEapolPkt,
                                    sizeof (EAPOL_PACKET));
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMConnecting: Error in writing Start Pkt to port %ld",
                    dwRetCode);
            break;
        }

        TRACE1 (EAPOL, "Setting state CONNECTING for port %s", pPCB->pszFriendlyName);

        pPCB->State = EAPOLSTATE_CONNECTING;
        SET_EAPOL_START_TIMER(pPCB);

    } while (FALSE);

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

    TRACE1 (EAPOL, "FSMConnecting completed for port %s", pPCB->pszFriendlyName);
    return dwRetCode;
}


//
// FSMAcquired
//
// Description:
//      Function called when the port receives a EAP-Request/Identity packet.
//      EAP processing of the packet occurs and a EAP-Response/Identity may
//      be sent out by EAP if required.
//      
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which data is being
//      processed
//      pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMAcquired (
        IN  EAPOL_PCB       *pPCB,
        IN  EAPOL_PACKET    *pEapolPkt
        )
{
    DWORD       dwComputerNameLen = 0;
    GUID        DeviceGuid;
    DWORD       dwRetCode= NO_ERROR;

    TRACE1 (EAPOL, "FSMAcquired entered for port %s", pPCB->pszFriendlyName);

#ifndef EAPOL_SERVICE

    ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
    (VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);

#endif

    do
    {

        // Indicate to EAP=Dll to cleanup any leftovers from earlier
        // authentication. This is to take care of cases where errors
        // occured in the earlier authentication and cleanup wasn't done
        if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMAcquired: Error in ElEapEnd = %ld",
                    dwRetCode);
            break;
        }

        // Restart timer with authPeriod
        // Even if there is error in ElEapWork, the authtimer timeout
        // should happen
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwauthPeriod,
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMAcquired: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        // Since an EAP Req-ID was received, reset EAPOL_Start count
        pPCB->ulStartCount = 0;


        // If current received EAP Id is the same the previous EAP Id
        // send the last EAPOL packet again

        if (((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Id == 
            pPCB->dwPreviousId)
        {
                
            TRACE0 (EAPOL, "FSMAcquired: Re-xmitting EAP_Packet to port");

            dwRetCode = ElWriteToPort (pPCB,
                            (CHAR *)pPCB->pbPreviousEAPOLPkt,
                            pPCB->dwSizeOfPreviousEAPOLPkt);
            if (dwRetCode != NO_ERROR)
            {
                TRACE1 (EAPOL, "FSMAcquired: Error in writing re-xmitted EAP_Packet to port %ld",
                        dwRetCode);
                break;
            }
        }
        else
        {

            // Process the EAP packet
            // ElEapWork will send out response if required
            if (( dwRetCode = ElEapWork (
                            pPCB,
                            (PPP_EAP_PACKET *)pEapolPkt->PacketBody
                            )) != NO_ERROR)
            {
                TRACE1 (EAPOL, "FSMAcquired: Error in ElEapWork %ld",
                        dwRetCode);
                break;
            }
        }

        TRACE1 (EAPOL, "Setting state ACQUIRED for port %s", pPCB->pszFriendlyName);

        SET_EAPOL_AUTH_TIMER(pPCB);
        pPCB->State = EAPOLSTATE_ACQUIRED;

    } while (FALSE);

    TRACE1 (EAPOL, "FSMAcquired completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// FSMAuthenticating
//
// Description:
//
// Function called when an non EAP-Request/Identity packet is received on the
// port. EAP processing of the data occurs.
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which data is being
//      processed
//      pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMAuthenticating (
        IN  EAPOL_PCB       *pPCB,
        IN  EAPOL_PACKET    *pEapolPkt
        )
{
    GUID            DeviceGuid;
    DWORD           dwRetCode = NO_ERROR;

    TRACE1 (EAPOL, "FSMAuthenticating entered for port %s", pPCB->pszFriendlyName);

#ifndef EAPOL_SERVICE

    ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
    (VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);

#endif

    do
    {

        // Restart timer with authPeriod
        // Even if there is error in ElEapWork, the authtimer timeout
        // should happen
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwauthPeriod,
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMAuthenticating: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        // If current received EAP Id is the same the previous EAP Id
        // send the last EAPOL packet again
	    // For EAPCODE_Success and EAPCODE_Failure, the value of id field
	    // will not be increment, Refer to EAP RFC 

        if ((((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Id 
                    == pPCB->dwPreviousId) &&
                (((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Code 
                    !=  EAPCODE_Success) &&
                (((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Code 
                    !=  EAPCODE_Failure))
        {

            TRACE0 (EAPOL, "FSMAcquired: Re-xmitting EAP_Packet to port");

            dwRetCode = ElWriteToPort (pPCB,
                            (CHAR *)pPCB->pbPreviousEAPOLPkt,
                            pPCB->dwSizeOfPreviousEAPOLPkt);
            if (dwRetCode != NO_ERROR)
            {
                TRACE1 (EAPOL, "FSMAcquired: Error in writing re-xmitted EAP_Packet to port = %ld",
                        dwRetCode);
                break;
            }
        }
        else
        {
            // Process the EAP packet
            // ElEapWork will send out response if required
            if (( dwRetCode = ElEapWork (
                            pPCB,
                            (PPP_EAP_PACKET *)pEapolPkt->PacketBody
                            )) != NO_ERROR)
            {
                TRACE1 (EAPOL, "FSMAuthenticating: Error in ElEapWork %ld",
                        dwRetCode);
                break;
            }
        }


        TRACE1 (EAPOL, "Setting state AUTHENTICATING for port %s", pPCB->pszFriendlyName);

        SET_EAPOL_AUTH_TIMER(pPCB);
        pPCB->State = EAPOLSTATE_AUTHENTICATING;

    } while (FALSE);

    TRACE1 (EAPOL, "FSMAuthenticating completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// FSMHeld
//
// Description:
//      Function called when a EAP-Failure packet is received in the
//      Authenticating state. State machine is held for heldPeriod before
//      re-authentication can occur.
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which data is being
//      processed
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMHeld (
        IN  EAPOL_PCB   *pPCB
        )
{
    DWORD       dwRetCode = NO_ERROR;

    TRACE1 (EAPOL, "FSMHeld entered for port %s", pPCB->pszFriendlyName);

    do 
    {
#ifdef DRAFT7
        if (g_dwMachineAuthEnabled)
        {
#endif

        pPCB->dwAuthFailCount++;

        if (pPCB->dwAuthFailCount <= EAPOL_MAX_AUTH_FAIL_COUNT)
        {
            TRACE1 (EAPOL, "Restarting Held timer with time value = %ld",
                    pPCB->EapolConfig.dwheldPeriod);

            // Restart timer with heldPeriod
            RESTART_TIMER (pPCB->hTimer,
                    pPCB->EapolConfig.dwheldPeriod,
                    "PCB",
                    &dwRetCode);
        }
        else
        {
            TRACE1 (EAPOL, "Restarting Held timer with extended time value = %ld",
                    (pPCB->dwAuthFailCount * (pPCB->EapolConfig.dwheldPeriod)));

            // Restart timer with heldPeriod times pPCB->dwAuthFailCount
            RESTART_TIMER (pPCB->hTimer,
                    ((pPCB->dwAuthFailCount) * (pPCB->EapolConfig.dwheldPeriod)),
                    "PCB",
                    &dwRetCode);
        }

#ifdef DRAFT7
        }
        else
        {

        TRACE1 (EAPOL, "Restarting Held timer with time value = %ld",
                pPCB->EapolConfig.dwheldPeriod);

        // Restart timer with heldPeriod
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwheldPeriod,
                "PCB",
                &dwRetCode);

        } // g_dwMachineAuthEnabled
#endif
            
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (EAPOL, "FSMHeld: Error in RESTART_TIMER %ld",
                    dwRetCode);

            break;
        }

        // Free Identity buffer

        if (pPCB->pszIdentity != NULL)
        {
            FREE (pPCB->pszIdentity);
            pPCB->pszIdentity = NULL;
        }
    
        // Free Password buffer
    
        if (pPCB->pszPassword != NULL)
        {
            FREE (pPCB->pszPassword);
            pPCB->pszPassword = NULL;
        }
    
        // Free user-specific data in the PCB
    
        if (pPCB->pCustomAuthUserData != NULL)
        {
            FREE (pPCB->pCustomAuthUserData);
            pPCB->pCustomAuthUserData = NULL;
        }
    
        // Free connection data
    
        if (pPCB->pCustomAuthConnData != NULL)
        {
            FREE (pPCB->pCustomAuthConnData);
            pPCB->pCustomAuthConnData = NULL;
        }
    
        // Since there has been an error in credentials, start afresh
        // the authentication. Credentials may have changed e.g. certs 
        // may be renewed, MD5 credentials corrected etc.

        pPCB->fGotUserIdentity = FALSE;
    
        TRACE1 (EAPOL, "Setting state HELD for port %s", pPCB->pszFriendlyName);

        pPCB->State = EAPOLSTATE_HELD;
        SET_EAPOL_HELD_TIMER(pPCB);

        TRACE1 (EAPOL, "FSMHeld: Port %s set to HELD state",
                pPCB->pszDeviceGUID);

    } while (FALSE);
    
    TRACE1 (EAPOL, "FSMHeld completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// FSMAuthenticated
//
// Description:
//
// Function called when a EAP-Success packet is received or MaxStart 
// EAPOL_Startpackets have been sent out, but no EAP-Request/Identity 
// packets were received. If EAP-Success packet is request, DHCP client 
// is restarted to get a new IP address.
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which data is being
//      processed
//      pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMAuthenticated (
        IN  EAPOL_PCB       *pPCB,
        IN  EAPOL_PACKET   *pEapolPkt
        )
{
    DHCP_PNP_CHANGE     DhcpPnpChange;
    DWORD               dwRetCode = NO_ERROR;

    TRACE1 (EAPOL, "FSMAuthenticated entered for port %s", 
            pPCB->pszFriendlyName);

    do
    {
        // Shutdown earlier EAP session
        ElEapEnd (pPCB);

        // Call DHCP only if state machine went through authentication
        // If FSM is getting AUTHENTICATED by default, don't call DHCP

        // if (pPCB->ulStartCount < pPCB->EapolConfig.dwmaxStart)
        {
            // Call DHCP to do PnP
            ZeroMemory(&DhcpPnpChange, sizeof(DHCP_PNP_CHANGE));
            DhcpPnpChange.Version = DHCP_PNP_CHANGE_VERSION_0;
            if ((dwRetCode = DhcpHandlePnPEvent(0, 
                        DHCP_CALLER_TCPUI, 
                        NULL,
                        //pPCB->pszDeviceGUID,
                        &DhcpPnpChange, 
                        NULL)) != NO_ERROR)
            {
                TRACE1 (EAPOL, "FSMAuthenticated: DHCPHandlePnPEvent returned error %ld",
                        dwRetCode);
                break;
            }
            TRACE0 (EAPOL, "FSMAuthenticated: DHCPHandlePnPEvent successful");
        }
            
        TRACE1 (EAPOL, "Setting state AUTHENTICATED for port %s", pPCB->pszFriendlyName);

        pPCB->State = EAPOLSTATE_AUTHENTICATED;

    } while (FALSE);

    TRACE1 (EAPOL, "FSMAuthenticated completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// FSMRxKey
//
// Description:
//      Function called when an EAPOL-Key packet is received in the 
//      Authenticated state. The WEP key is decrypted and
//      plumbed down to the NIC driver.
//
// Arguments:
//      pPCB - Pointer to the PCB for the port on which data is being
//      processed
//      pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
FSMRxKey (
        IN  EAPOL_PCB       *pPCB,
        IN  EAPOL_PACKET   *pEapolPkt
        )
{
    EAPOL_KEY_DESC      *pKeyDesc = NULL;
    EAPOL_KEY_DESC_D8   *pKeyDesc_D8 = NULL;
    EAPOL_PACKET_D8     EapolPktD8;
    EAPOL_PACKET_D8     *pEapolPktD8 = NULL;
    ULONGLONG           ullReplayCheck = 0; 
    BYTE                bReplayCheck[8];
    BYTE                *pbMD5EapolPkt = NULL;
    DWORD               dwMD5EapolPktLen = 0;
    MD5_CTX             MD5Context;
    DWORD               dwEapPktLen = 0;
    DWORD               dwIndex = 0;
    BYTE                bHMACMD5HashBuffer[MD5DIGESTLEN];
    RC4_KEYSTRUCT       rc4key;
    BYTE                bKeyBuffer[48];
    BYTE                *pbKeyToBePlumbed = NULL;
    DWORD               dwKeyLength = 0;
    NDIS_802_11_WEP     *pNdisWEPKey = NULL;

    DWORD               dwRetCode = NO_ERROR;

    TRACE1 (EAPOL, "FSMRxKey entered for port %s", pPCB->pszFriendlyName);

    do
    {
        if (!pPCB->fRemoteEnd8021XD8)
        {
        // DRAFT 7

        pKeyDesc = (EAPOL_KEY_DESC *)pEapolPkt->PacketBody;

        dwKeyLength = WireToHostFormat16 (pKeyDesc->KeyLength);

        TRACE4 (EAPOL, "Signature Type = %ld, \n Encrypt Type = %ld, \n KeyLength = %ld, \n KeyIndex = %ld",
                pKeyDesc->SignatureType,
                pKeyDesc->EncryptType,
                dwKeyLength,
                pKeyDesc->KeyIndex
                );

        // For Draft 8, do not check for non-existing fields

        if (pKeyDesc->SignatureType != 1)
        {
            TRACE1 (EAPOL, "FSMRxKey: Invalid signature type = %ld",
                    pKeyDesc->SignatureType);
            // log
            break;
        }

        if (pKeyDesc->EncryptType != 1)
        {
            TRACE1 (EAPOL, "FSMRxKey: Invalid encryption type = %ld",
                    pKeyDesc->EncryptType);
            // log
            break;
        }

        memcpy ((BYTE *)bReplayCheck, 
                (BYTE *)pKeyDesc->ReplayCounter, 
                8*sizeof(BYTE));

        ullReplayCheck = ((*((PBYTE)(bReplayCheck)+0) << 56) +
                         (*((PBYTE)(bReplayCheck)+1) << 48) +
                         (*((PBYTE)(bReplayCheck)+2) << 40) +
                         (*((PBYTE)(bReplayCheck)+3) << 32) +
                         (*((PBYTE)(bReplayCheck)+4) << 24) +
                         (*((PBYTE)(bReplayCheck)+5) << 16) +
                         (*((PBYTE)(bReplayCheck)+6) << 8) +
                         (*((PBYTE)(bReplayCheck)+7)));

        //
        // Check validity of Key message using the ReplayCounter field
        // Verify if it is in sync with the last ReplayCounter value 
        // received
        //
        
        TRACE0 (EAPOL, "Incoming Replay counter ======= ");
        EAPOL_DUMPBA ((BYTE *)&ullReplayCheck, 8);
        TRACE0 (EAPOL, "Last Replay counter ======= ");
                EAPOL_DUMPBA ((BYTE *)&(pPCB->ullLastReplayCounter), 8);

        if (ullReplayCheck <= pPCB->ullLastReplayCounter)
        {
            TRACE0 (EAPOL, "FSMRxKey: Replay counter is not in sync, something is wrong");
            // log
            break;
        }
        
        // If valid ReplayCounter, save it in the PCB for future check
        pPCB->ullLastReplayCounter = ullReplayCheck;


        TRACE0 (EAPOL, "Replay counter in desc ======");
        EAPOL_DUMPBA (pKeyDesc->ReplayCounter, 8);

        //
        // Verify if the MD5 hash generated on the EAPOL packet,
        // with Signature nulled out, is the same as the signature
        // Use the MPPERecv key as the secret
        //

        dwEapPktLen = WireToHostFormat16 (pEapolPkt->PacketBodyLength);
        dwMD5EapolPktLen = sizeof (EAPOL_PACKET) - sizeof(pEapolPkt->EthernetType) - 1 + dwEapPktLen;
        if ((pbMD5EapolPkt = (BYTE *) MALLOC (dwMD5EapolPktLen)) == NULL)
        {
            TRACE0 (EAPOL, "FSMRxKey: Error in MALLOC for pbMD5EapolPkt");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        memcpy ((BYTE *)pbMD5EapolPkt, (BYTE *)pEapolPkt+sizeof(pEapolPkt->EthernetType), dwMD5EapolPktLen);

        //
        // Null out the signature in the key descriptor copy, to calculate
        // the hash on the supplicant side
        //

        ZeroMemory ((BYTE *)(pbMD5EapolPkt
                            - sizeof(pEapolPkt->EthernetType) +
                            sizeof(EAPOL_PACKET) - 1 + // pEapolPkt->Body
                            sizeof(EAPOL_KEY_DESC)- // End of EAPOL_KEY_DESC
                            MD5DIGESTLEN-1), // Signature field
                            MD5DIGESTLEN);

        (VOID) ElGetHMACMD5Digest (
            pbMD5EapolPkt,
            dwMD5EapolPktLen,
            pPCB->pbMPPERecvKey,
            pPCB->dwMPPERecvKeyLength,
            bHMACMD5HashBuffer
            );

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash body ==");
        EAPOL_DUMPBA (pbMD5EapolPkt, dwMD5EapolPktLen);

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash secret ==");
        EAPOL_DUMPBA (pPCB->pbMPPERecvKey, pPCB->dwMPPERecvKeyLength);

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash generated by Supplicant");
        EAPOL_DUMPBA (bHMACMD5HashBuffer, MD5DIGESTLEN);

        TRACE0 (EAPOL, "FSMRxKey: Signature sent in EAPOL_KEY_DESC");
        EAPOL_DUMPBA (pKeyDesc->KeySignature, MD5DIGESTLEN);

        //
        // Check if HMAC-MD5 hash in received packet is what is expected
        //
        if (memcmp (bHMACMD5HashBuffer, pKeyDesc->KeySignature, MD5DIGESTLEN) != 0)
        {
            TRACE0 (EAPOL, "FSMRxKey: Signature in Key Desc does not match, potential security attack");
            // log
            break;
        }
            
        //
        // Decrypt the multicast WEP key if it has been provided
        //

        // Check if there is Key Material (5/16 bytes) at the end of 
        // the Key Descriptor

        if (WireToHostFormat16 (pEapolPkt->PacketBodyLength) > sizeof (EAPOL_KEY_DESC))

        {
            memcpy ((BYTE *)bKeyBuffer, (BYTE *)pKeyDesc->Key_IV, 16);
            memcpy ((BYTE *)&bKeyBuffer[16], (BYTE *)pPCB->pbMPPESendKey, 32);

            rc4_key (&rc4key, 48, bKeyBuffer);
            rc4 (&rc4key, dwKeyLength, pKeyDesc->Key);

            TRACE0 (EAPOL, " ========= The multicast key is ============= ");
            EAPOL_DUMPBA (pKeyDesc->Key, dwKeyLength);


            // Use the unencrypted key in the Key Desc as the encryption key

            pbKeyToBePlumbed = pKeyDesc->Key;
            
        }
        else
        {
            // Use the MPPESend key as the encryption key

            pbKeyToBePlumbed = (BYTE *)pPCB->pbMPPESendKey;
        }

        if ((pNdisWEPKey = MALLOC ( sizeof(NDIS_802_11_WEP)-1+dwKeyLength )) 
                == NULL)
        {
            TRACE0 (EAPOL, "FSMRxKey: MALLOC failed for pNdisWEPKey");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pNdisWEPKey->Length = sizeof(NDIS_802_11_WEP) - 1 + dwKeyLength;
        memcpy ((BYTE *)pNdisWEPKey->KeyMaterial, (BYTE *)pbKeyToBePlumbed,
                dwKeyLength);
        pNdisWEPKey->KeyLength = dwKeyLength;


        // Create the long index out of the byte index got from AP
        // If MSB in byte is set, set MSB in ulong format

        if (pKeyDesc->KeyIndex & 0x80)
        {
            pNdisWEPKey->KeyIndex = 0x80000000;
        }
        else
        {
            pNdisWEPKey->KeyIndex = 0x00000000;
        }

        pNdisWEPKey->KeyIndex |= (pKeyDesc->KeyIndex & 0x03);

        TRACE1 (ANY, "FSMRxKey: Key Index is %x", pNdisWEPKey->KeyIndex);


        // Use NDISUIO to plumb the key to the driver

        if ((dwRetCode = ElNdisuioSetOIDValue (
                                    pPCB->hPort,
                                    OID_802_11_ADD_WEP,
                                    (BYTE *)pNdisWEPKey,
                                    pNdisWEPKey->Length)) != NO_ERROR)
        {
            TRACE1 (PORT, "FSMRxKey: ElNdisuioSetOIDValue failed with error %ld",
                    dwRetCode);
        }

        }
        else
        {
        // DRAFT 8

        // Point beyond Signature Type for structure alignment
        pKeyDesc_D8 = (EAPOL_KEY_DESC_D8 *)(pEapolPkt->PacketBody);

        dwKeyLength = WireToHostFormat16 (pKeyDesc_D8->KeyLength);

        TRACE3 (EAPOL, "Descriptor type = %ld, \n KeyLength = %ld, \n KeyIndex = %ld",
                pKeyDesc_D8->DescriptorType,
                dwKeyLength,
                pKeyDesc_D8->KeyIndex
                );

        memcpy ((BYTE *)bReplayCheck, 
                (BYTE *)pKeyDesc_D8->ReplayCounter, 
                8*sizeof(BYTE));

        ullReplayCheck = ((*((PBYTE)(bReplayCheck)+0) << 56) +
                         (*((PBYTE)(bReplayCheck)+1) << 48) +
                         (*((PBYTE)(bReplayCheck)+2) << 40) +
                         (*((PBYTE)(bReplayCheck)+3) << 32) +
                         (*((PBYTE)(bReplayCheck)+4) << 24) +
                         (*((PBYTE)(bReplayCheck)+5) << 16) +
                         (*((PBYTE)(bReplayCheck)+6) << 8) +
                         (*((PBYTE)(bReplayCheck)+7)));

        //
        // Check validity of Key message using the ReplayCounter field
        // Verify if it is in sync with the last ReplayCounter value 
        // received
        //
        
        TRACE0 (EAPOL, "Incoming Replay counter ======= ");
        EAPOL_DUMPBA ((BYTE *)&ullReplayCheck, 8);
        TRACE0 (EAPOL, "Last Replay counter ======= ");
                EAPOL_DUMPBA ((BYTE *)&(pPCB->ullLastReplayCounter), 8);

        if (ullReplayCheck < pPCB->ullLastReplayCounter)
        {
            TRACE0 (EAPOL, "FSMRxKey: Replay counter is not in sync, something is wrong");
            // log
            break;
        }
        
        // If valid ReplayCounter, save it in the PCB for future check
        pPCB->ullLastReplayCounter = ullReplayCheck;

        TRACE1 (EAPOL, "Replay counter ======= %lx", ullReplayCheck);

        TRACE0 (EAPOL, "Replay counter in desc ======");
        EAPOL_DUMPBA (pKeyDesc_D8->ReplayCounter, 8);

        //
        // Verify if the MD5 hash generated on the EAPOL packet,
        // with Signature nulled out, is the same as the signature
        // Use the MPPERecv key as the secret
        //

        {
            ZeroMemory (&EapolPktD8, sizeof (EAPOL_PACKET_D8));

            memcpy (EapolPktD8.EthernetType, pEapolPkt->EthernetType, 2);
            EapolPktD8.ProtocolVersion = pEapolPkt->ProtocolVersion;
            EapolPktD8.PacketType = pEapolPkt->PacketType;
            memcpy (EapolPktD8.PacketBodyLength, pEapolPkt->PacketBodyLength, 
                    2);
            memcpy ((BYTE *)&(EapolPktD8.AuthResultCode), (BYTE *)pEapolPkt - 2, 2);

            memcpy ((BYTE *)pEapolPkt - 2, (BYTE *)&EapolPktD8,
                    sizeof(EAPOL_PACKET_D8)-1);

            pEapolPktD8 = (EAPOL_PACKET_D8 *)((BYTE *)pEapolPkt - 2);
        }

        dwEapPktLen = WireToHostFormat16 (pEapolPktD8->PacketBodyLength);
        dwMD5EapolPktLen = sizeof (EAPOL_PACKET_D8) - sizeof(pEapolPktD8->EthernetType) - 1 + dwEapPktLen;
        if ((pbMD5EapolPkt = (BYTE *) MALLOC (dwMD5EapolPktLen)) == NULL)
        {
            TRACE0 (EAPOL, "FSMRxKey: Error in MALLOC for pbMD5EapolPkt");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        memcpy ((BYTE *)pbMD5EapolPkt, (BYTE *)pEapolPktD8+sizeof(pEapolPktD8->EthernetType), dwMD5EapolPktLen);

        //
        // Null out the signature in the key descriptor copy, to calculate
        // the hash on the supplicant side
        //

        // Draft 8 has different KEY_DESC size
        ZeroMemory ((BYTE *)(pbMD5EapolPkt
                            - sizeof(pEapolPktD8->EthernetType) +
                            sizeof(EAPOL_PACKET_D8) - 1 + // pEapolPktD8->Body
                            sizeof(EAPOL_KEY_DESC_D8) - // End of EAPOL_KEY_DESC
                            MD5DIGESTLEN-1), // Signature field
                            MD5DIGESTLEN);

        (VOID) ElGetHMACMD5Digest (
            pbMD5EapolPkt,
            dwMD5EapolPktLen,
            pPCB->pbMPPERecvKey,
            pPCB->dwMPPERecvKeyLength,
            bHMACMD5HashBuffer
            );

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash body ==");
        EAPOL_DUMPBA (pbMD5EapolPkt, dwMD5EapolPktLen);

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash secret ==");
        EAPOL_DUMPBA (pPCB->pbMPPERecvKey, pPCB->dwMPPERecvKeyLength);

        TRACE0 (EAPOL, "FSMRxKey: MD5 Hash generated by Supplicant");
        EAPOL_DUMPBA (bHMACMD5HashBuffer, MD5DIGESTLEN);

        TRACE0 (EAPOL, "FSMRxKey: Signature sent in EAPOL_KEY_DESC");
        EAPOL_DUMPBA (pKeyDesc_D8->KeySignature, MD5DIGESTLEN);

        //
        // Check if HMAC-MD5 hash in received packet is what is expected
        //
        if (memcmp (bHMACMD5HashBuffer, pKeyDesc_D8->KeySignature, MD5DIGESTLEN) != 0)
        {
            TRACE0 (EAPOL, "FSMRxKey: Signature in Key Desc does not match, potential security attack");
            // log
            break;
        }
            
        //
        // Decrypt the multicast WEP key if it has been provided
        //

        // Check if there is Key Material (5/16 bytes) at the end of 
        // the Key Descriptor

        if (WireToHostFormat16 (pEapolPktD8->PacketBodyLength) > sizeof (EAPOL_KEY_DESC))

        {
            memcpy ((BYTE *)bKeyBuffer, (BYTE *)pKeyDesc_D8->Key_IV, 16);
            memcpy ((BYTE *)&bKeyBuffer[16], (BYTE *)pPCB->pbMPPESendKey, 32);

            rc4_key (&rc4key, 48, bKeyBuffer);
            rc4 (&rc4key, dwKeyLength, pKeyDesc_D8->Key);

            TRACE0 (EAPOL, " ========= The multicast key is ============= ");
            EAPOL_DUMPBA (pKeyDesc_D8->Key, dwKeyLength);


            // Use the unencrypted key in the Key Desc as the encryption key

            pbKeyToBePlumbed = pKeyDesc_D8->Key;
            
        }
        else
        {
            // Use the MPPESend key as the encryption key

            pbKeyToBePlumbed = (BYTE *)pPCB->pbMPPESendKey;
        }

        if ((pNdisWEPKey = MALLOC ( sizeof(NDIS_802_11_WEP)-1+dwKeyLength )) 
                == NULL)
        {
            TRACE0 (EAPOL, "FSMRxKey: MALLOC failed for pNdisWEPKey");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pNdisWEPKey->Length = sizeof(NDIS_802_11_WEP) - 1 + dwKeyLength;
        memcpy ((BYTE *)pNdisWEPKey->KeyMaterial, (BYTE *)pbKeyToBePlumbed,
                dwKeyLength);
        pNdisWEPKey->KeyLength = dwKeyLength;


        // Create the long index out of the byte index got from AP
        // If MSB in byte is set, set MSB in ulong format

        if (pKeyDesc_D8->KeyIndex & 0x80)
        {
            pNdisWEPKey->KeyIndex = 0x80000000;
        }
        else
        {
            pNdisWEPKey->KeyIndex = 0x00000000;
        }

        pNdisWEPKey->KeyIndex |= (pKeyDesc_D8->KeyIndex & 0x03);

        TRACE1 (ANY, "FSMRxKey: Key Index is %x", pNdisWEPKey->KeyIndex);


        // Use NDISUIO to plumb the key to the driver

        if ((dwRetCode = ElNdisuioSetOIDValue (
                                    pPCB->hPort,
                                    OID_802_11_ADD_WEP,
                                    (BYTE *)pNdisWEPKey,
                                    pNdisWEPKey->Length)) != NO_ERROR)
        {
            TRACE1 (PORT, "FSMRxKey: ElNdisuioSetOIDValue failed with error %ld",
                    dwRetCode);
        }

        }
    } while (FALSE);

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

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

    TRACE1 (EAPOL, "FSMRxKey completed for port %s", pPCB->pszFriendlyName);

    return dwRetCode;
}


//
// ElTimeoutCallbackRoutine
//
// Description:
//
// Function called when any timer work item queued on the global timer 
// queue expires. Depending on the state in which the port is when the timer
// expires, the port moves to the next state.
//
// Arguments:
//      pvContext - Pointer to context. In this case, it is pointer to a PCB 
//      fTimerOfWaitFired - Unused
//
// Return values:
//

VOID 
ElTimeoutCallbackRoutine (
        IN  PVOID       pvContext,
        IN  BOOLEAN     fTimerOfWaitFired
        )
{
    EAPOL_PCB       *pPCB;

    TRACE0 (EAPOL, "ElTimeoutCallbackRoutine entered");
    
    do 
    {
        // Context should not be NULL
        if (pvContext == NULL)
        {
            TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: pvContext is NULL. Invalid timeout callback");
            break;
        }

        // PCB is guaranteed to exist until all timers are fired
            
        // Verify if Port is still active
        pPCB = (EAPOL_PCB *)pvContext;
        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            // Port is not active
            RELEASE_WRITE_LOCK (&(pPCB->rwLock));
            TRACE1 (PORT, "ElTimeoutCallbackRoutine: Port %s is inactive",
                    pPCB->pszDeviceGUID);
            break;
        }

        // Check the timer has been changed
        // If the current time is less than the programmed timeout on
        // the PCB, either timer component has shot off timer earlier
        // or the timer fired but someone changed it in the meanwhile
        if (pPCB->ulTimeout > GetTickCount())
        {
            TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: Timeout value has been changed or Timer fired earlier than required");
            break;
        }
    
        // Check the current state of the state machine 
        // We can do additional checks such as flagging which timer was fired
        // and in the timeout checking if the PCB state has remained the same
        // Else bail out
    
        switch (pPCB->State)
        {
            case EAPOLSTATE_CONNECTING:
                if (!EAPOL_START_TIMER_SET(pPCB))
                {
                    TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Connecting state", CHECK_EAPOL_TIMER(pPCB));
                    break;
                }
                FSMConnecting(pPCB);
                break;
    
            case EAPOLSTATE_ACQUIRED:
                if (!EAPOL_AUTH_TIMER_SET(pPCB))
                {
                    TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Acquired state", CHECK_EAPOL_TIMER(pPCB));
                    break;
                }
                FSMConnecting(pPCB);
                break;
                
            case EAPOLSTATE_AUTHENTICATING:
                if (!EAPOL_AUTH_TIMER_SET(pPCB))
                {
                    TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Authenticating state", CHECK_EAPOL_TIMER(pPCB));
                    break;
                }
                FSMConnecting(pPCB);
                break;
                
            case EAPOLSTATE_HELD:
                if (!EAPOL_HELD_TIMER_SET(pPCB))
                {
                    TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Held state", CHECK_EAPOL_TIMER(pPCB));
                    break;
                }
                FSMConnecting(pPCB);
                break;

            case EAPOLSTATE_DISCONNECTED:
                TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: No action in Disconnected state");
                break;
                
            case EAPOLSTATE_LOGOFF:
                TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: No action in Logoff state");
                break;
                
            default:
                TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: Critical Error. Invalid state after timer expires ");
                break;
        }
    
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));

    } while (FALSE);
            
    TRACE0 (EAPOL, "ElTimeoutCallbackRoutine completed");

    return;
}


//
// ElEapWork
//
// Description:
//
// Function called when an EAPOL packet of type EAP_Packet is received 
// The EAP packet is passed to the EAP module for processing.
// Depending on the result of the processing, a EAP Response packet
// is sent or the incoming packet is ignored.
//
// Input arguments:
//  pPCB - Pointer to PCB for the port on which data is being processed
//  pRecvPkt - Pointer to EAP packet in the data received from the remote end
//              
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

//
// ISSUE: Rewrite with do {} while(FALSE)
//

DWORD
ElEapWork (
    IN EAPOL_PCB        *pPCB,
    IN PPP_EAP_PACKET   *pRecvPkt
    )
{
    DWORD           dwLength = 0;
    ELEAP_RESULT    EapResult;
    PPP_EAP_PACKET  *pSendPkt;
    EAPOL_PACKET    *pEapolPkt;
    GUID            DeviceGuid;
    WCHAR           awszNotificationMsg[MAX_NOTIFICATION_MSG_SIZE];
    DWORD           dwReceivedId = 0;
    DWORD           dwDraft8HdrIncr = 0;
    DWORD           dwRetCode = NO_ERROR;

    //
    // If the protocol has not been started yet, call ElEapBegin
    //

    if (!(pPCB->fEapInitialized))
    {
        if (ElEapBegin (pPCB) != NO_ERROR)
        {
            TRACE1 (EAPOL, "ElEapWork: Error in ElEapBegin = %ld", dwRetCode);
            return dwRetCode;
        }
    }

    ZeroMemory(&EapResult, sizeof(EapResult));
    
    // Create buffer for EAPOL + EAP and pass pointer to EAP header

    pEapolPkt = (EAPOL_PACKET *) MALLOC (MAX_EAPOL_BUFFER_SIZE); 

    TRACE1 (EAPOL, "ElEapWork: EapolPkt created at %p", pEapolPkt);

    if (pEapolPkt == NULL)
    {
        TRACE0 (EAPOL, "ElEapWork: Error allocating EAP buffer");
        dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
        return dwRetCode;
    }

    // Point to EAP header
    pSendPkt = (PPP_EAP_PACKET *)((PBYTE)pEapolPkt + sizeof (EAPOL_PACKET) - 1);

    if (pRecvPkt != NULL)
    {
        dwReceivedId = pRecvPkt->Id;
    }

    if (pPCB->fRemoteEnd8021XD8)
    {
        // Account for 2 bytes of AuthResultCode
        dwDraft8HdrIncr = 2;
    }

    dwRetCode = ElEapMakeMessage (pPCB,
                                pRecvPkt,
                                pSendPkt,
                                MAX_EAPOL_BUFFER_SIZE 
                                - sizeof(EAPOL_PACKET) - 1 - dwDraft8HdrIncr,
                                &EapResult
                                );

    // Notification message for the user

    if (NULL != EapResult.pszReplyMessage)
    {
        // Free earlier notication with the PCB
        if (pPCB->pszEapReplyMessage != NULL)
        {
            FREE (pPCB->pszEapReplyMessage);
            pPCB->pszEapReplyMessage = NULL;
        }

        pPCB->pszEapReplyMessage = EapResult.pszReplyMessage;

        // Notify user of message

#ifndef EAPOL_SERVICE

        ZeroMemory (awszNotificationMsg, MAX_NOTIFICATION_MSG_SIZE);
        if (0 == MultiByteToWideChar (
                    CP_ACP,
                    0,
                    pPCB->pszEapReplyMessage,
                    -1,
                    awszNotificationMsg, 
                    MAX_NOTIFICATION_MSG_SIZE))
        {
            dwRetCode = GetLastError();
    
            TRACE2 (EAPOL,"MultiByteToWideChar(%s) failed: %d",
                                        pPCB->pszEapReplyMessage,
                                        dwRetCode);
            FREE (pEapolPkt);
            pEapolPkt = NULL;
                
            return dwRetCode;
            
        }

        // Display notification message using sys tray balloon
        // on interface icon
        ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
        (VOID)EAPOLMANNotification (&DeviceGuid,
                                    awszNotificationMsg,
                                    0);

#endif

        TRACE1 (EAPOL, "ElEapWork: Notified user of EAP data = %s",
              pPCB->pszEapReplyMessage);
    }

    if (dwRetCode != NO_ERROR)
    {
        switch (dwRetCode)
        {
            case ERROR_PPP_INVALID_PACKET:

                TRACE0 (EAPOL, "ElEapWork: Silently discarding invalid auth packet");
                break;
    
            default:

                TRACE1 (EAPOL, "ElEapWork: ElEapMakeMessage returned error %ld",
                                                                dwRetCode);

                // NotifyCallerOfFailure (pPCB, dwRetCode);

                break;
        }

        // Free up memory reserved for packet
        FREE (pEapolPkt);
        pEapolPkt = NULL;

        return dwRetCode;
    }

    //
    // Check to see if we have to save any user data
    //

    if (EapResult.fSaveUserData) 
    {
        if ((dwRetCode = ElSetEapUserInfo (
                        pPCB->hUserToken,
                        pPCB->pszDeviceGUID,
                        pPCB->dwEapTypeToBeUsed,
                        pPCB->pszSSID,
                        EapResult.pUserData,
                        EapResult.dwSizeOfUserData)) != NO_ERROR)
        {
            TRACE1 (EAPOL, "ElEapWork: ElSetEapUserInfo failed with error = %d",
                    dwRetCode);
            if (pEapolPkt != NULL)
            {
                FREE (pEapolPkt);
                pEapolPkt = NULL;
            }
            return dwRetCode;
        }

        TRACE1 (EAPOL, "ElEapWork: Saved EAP data for user, dwRetCode = %d", 
                dwRetCode);
    }

    //
    // Check to see if we have to save any connection data
    //

    if ((EapResult.fSaveConnectionData ) &&
         ( 0 != EapResult.SetCustomAuthData.dwSizeOfConnectionData ) )
    {
           
        if ((dwRetCode = ElSetCustomAuthData (
                        pPCB->pszDeviceGUID,
                        pPCB->dwEapTypeToBeUsed,
                        pPCB->pszSSID,
                        EapResult.SetCustomAuthData.pConnectionData,
                        EapResult.SetCustomAuthData.dwSizeOfConnectionData
                        )) != NO_ERROR)
        {
            TRACE1 ( EAPOL, "ElEapWork: ElSetCustomAuthData failed with error = %d",
                    dwRetCode);
            FREE (pEapolPkt);
            pEapolPkt = NULL;
            return dwRetCode;
        }

        TRACE0 ( EAPOL, "ElEapWork: Saved EAP data for connection" );
    }

    switch( EapResult.Action )
    {

        case ELEAP_Send:
        case ELEAP_SendAndDone:

            // Send out EAPOL packet

            memcpy ((BYTE *)pEapolPkt->EthernetType, 
                    (BYTE *)pPCB->bEtherType, 
                    SIZE_ETHERNET_TYPE);
            pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
            pEapolPkt->PacketType = EAP_Packet;

            // The EAP packet length is in the packet returned back by 
            // the Dll MakeMessage
            // In case of Notification and Identity Response, it is in
            // EapResult.wSizeOfEapPkt

            if (EapResult.wSizeOfEapPkt == 0)
            {
                EapResult.wSizeOfEapPkt = 
                    WireToHostFormat16 (pSendPkt->Length);
            }
            HostToWireFormat16 ((WORD) EapResult.wSizeOfEapPkt,
                    (BYTE *)pEapolPkt->PacketBodyLength);


            // Make a copy of the EAPOL packet in the PCB
            // Will be used during retransmission

            if (pPCB->pbPreviousEAPOLPkt != NULL)
            {
                FREE (pPCB->pbPreviousEAPOLPkt);
            }
            pPCB->pbPreviousEAPOLPkt = 
                MALLOC (sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);

            if (pPCB->pbPreviousEAPOLPkt == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (EAPOL, "ElEapWork: MALLOC failed for pbPreviousEAPOLPkt");
                if (pEapolPkt != NULL)
                {
                    FREE (pEapolPkt);
                    pEapolPkt = NULL;
                }
                return dwRetCode;
            }

            memcpy (pPCB->pbPreviousEAPOLPkt, pEapolPkt, 
                    sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);

            pPCB->dwSizeOfPreviousEAPOLPkt = 
                sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1;

            pPCB->dwPreviousId = dwReceivedId;


            // Send packet out on the port
            dwRetCode = ElWriteToPort (pPCB,
                            (CHAR *)pEapolPkt,
                            sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);
            if (dwRetCode != NO_ERROR)
            {
                TRACE1 (EAPOL, "ElEapWork: Error in writing EAP_Packet to port %ld",
                        dwRetCode);
                if (pEapolPkt != NULL)
                {
                    FREE (pEapolPkt);
                    pEapolPkt = NULL;
                }
                return dwRetCode;
            }

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

            // More processing to be done?
            // Supplicant side should not ever receive ELEAP_SendAndDone
            // result code

            if (EapResult.Action != ELEAP_SendAndDone)
            {
                break;
            }
            else
            {
                TRACE0 (EAPOL, "ElEapWork: ELEAP_SendAndDone wrong result received");
                ASSERT(0);
            }
    
        case ELEAP_Done:
    
            // Retrieve MPPE keys from the attributes information
            // returned by EAP-TLS

            switch (EapResult.dwError)
            {
            case NO_ERROR:
    
                TRACE0 (EAPOL, "ElEapWork: Authentication was successful");

                //
                // If authentication was successful
                //
    
                dwRetCode = ElExtractMPPESendRecvKeys (
                                            pPCB, 
                                            EapResult.pUserAttributes,
                                            (BYTE*)&(EapResult.abChallenge),
                                            (BYTE*)&(EapResult.abResponse));
    
                if (dwRetCode != NO_ERROR)
                {
                    FREE (pEapolPkt);
                    //NotifyCallerOfFailure (pPcb, dwRetCode);

                    return dwRetCode;
                }
    
                // ISSUE:
                // Do we want to retain UserAttributes
                // pPCB->pAuthProtocolAttributes = EapResult.pUserAttributes;
    
                break;
    

            default:
                if (pEapolPkt != NULL)
                {
                    FREE (pEapolPkt);
                    pEapolPkt = NULL;
                }
                TRACE0 (EAPOL, "ElEapWork: Authentication FAILED");
                break;
            }

            // Free memory allocated for the packet, since no response
            // is going to be sent out
            if (pEapolPkt != NULL)
            {
                FREE (pEapolPkt);
                pEapolPkt = NULL;
            }

            break;
    
        case ELEAP_NoAction:
            // Free memory allocated for the packet, since nothing
            // is being done with it
            if (pEapolPkt != NULL)
            {
                FREE (pEapolPkt);
                pEapolPkt = NULL;
            }

            break;
    
        default:
    
            break;
    }
    
    if (pEapolPkt != NULL)
    {
        FREE (pEapolPkt);
        pEapolPkt = NULL;
    }

    //
    // Check to see if we have to bring up the InteractiveUI for EAP
    // i.e. Server cert confirmation etc.
    //
    
    if (EapResult.fInvokeEapUI)
    {
        ElInvokeInteractiveUI (pPCB, &(EapResult.InvokeEapUIData));
    }

    return dwRetCode;
}


//
//
// ElExtractMPPESendRecvKeys
//
// Description:
//      Function called if authentication was successful. The MPPE Send &
//      Recv keys are extracted from the RAS_AUTH_ATTRIBUTE passed from
//      the EAP DLL and stored in the PCB. The keys are used to decrypt
//      the multicast WEP key and also are used for media-based encrypting.
//
// Return values
// 
//      NO_ERROR - Success
//      Non-zero - Failure
//

DWORD
ElExtractMPPESendRecvKeys (
    IN  EAPOL_PCB               *pPCB, 
    IN  RAS_AUTH_ATTRIBUTE *    pUserAttributes,
    IN  BYTE *                  pChallenge,
    IN  BYTE *                  pResponse
)
{
    RAS_AUTH_ATTRIBUTE *    pAttribute;
    RAS_AUTH_ATTRIBUTE *    pAttributeSendKey;
    RAS_AUTH_ATTRIBUTE *    pAttributeRecvKey;
    DWORD                   dwRetCode = NO_ERROR;
    DWORD                   dwEncryptionPolicy  = 0;
    DWORD                   dwEncryptionTypes   = 0;


    //
    // Every time we get encryption keys, plumb them to the driver
    //

    do
    {
        pAttribute = ElAuthAttributeGetVendorSpecific (
                                311, 12, pUserAttributes);


        pAttributeSendKey = ElAuthAttributeGetVendorSpecific ( 311, 16,
                                pUserAttributes);
        pAttributeRecvKey = ElAuthAttributeGetVendorSpecific ( 311, 17,
                                pUserAttributes);

        if ((pAttributeSendKey != NULL) 
            && (pAttributeRecvKey != NULL))
        {
            //
            // Set the MS-MPPE-Send-Key and MS-MPPE-Recv-Key with 
            // the ethernet driver
            //

            ULONG ulSendKeyLength = 0;
            ULONG ulRecvKeyLength = 0;

            // Based on PPP code
            ulSendKeyLength = *(((BYTE*)(pAttributeSendKey->Value))+8);
            ulRecvKeyLength = *(((BYTE*)(pAttributeRecvKey->Value))+8);
            TRACE0 (EAPOL, "Send key = ");
            EAPOL_DUMPBA (((BYTE*)(pAttributeSendKey->Value))+9,
                    ulSendKeyLength);

            TRACE0 (EAPOL, "Recv key = ");
            EAPOL_DUMPBA (((BYTE*)(pAttributeRecvKey->Value))+9,
                    ulRecvKeyLength);

            pPCB->dwMPPESendKeyLength = ulSendKeyLength;
            pPCB->dwMPPERecvKeyLength = ulRecvKeyLength;

            //
            // Copy MPPE Send and Receive Keys into the PCB for later usage
            // These keys will be used to decrypt the global multicast key
            // (if any).
            //

            if (pPCB->dwMPPESendKeyLength != 0)
            {
                if (pPCB->pbMPPESendKey != NULL)
                {
                    FREE (pPCB->pbMPPESendKey);
                    pPCB->pbMPPESendKey = NULL;
                }

                if ((pPCB->pbMPPESendKey = MALLOC (pPCB->dwMPPESendKeyLength))
                        == NULL)
                {
                    TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: Error in Malloc for SendKey");
                    dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                    break;
                }
                memcpy (pPCB->pbMPPESendKey, 
                        ((BYTE*)(pAttributeSendKey->Value))+9, 
                        pPCB->dwMPPESendKeyLength);
            }

            if (pPCB->dwMPPERecvKeyLength != 0)
            {
                if (pPCB->pbMPPERecvKey != NULL)
                {
                    FREE (pPCB->pbMPPERecvKey);
                    pPCB->pbMPPERecvKey = NULL;
                }

                if ((pPCB->pbMPPERecvKey = MALLOC (pPCB->dwMPPERecvKeyLength))
                        == NULL)
                {
                    TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: Error in Malloc for RecvKey");
                    dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                    break;
                }
                memcpy (pPCB->pbMPPERecvKey, 
                        ((BYTE*)(pAttributeRecvKey->Value))+9, 
                        pPCB->dwMPPERecvKeyLength);
            }

            TRACE0 (EAPOL,"MPPE-Send/Recv-Keys set");

        }
        else
        {
            TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: pAttributeSendKey or pAttributeRecvKey == NULL");
        }

    } while (FALSE);

    if (dwRetCode != NO_ERROR)
    {
        if (pPCB->pbMPPESendKey != NULL)
        {
            FREE (pPCB->pbMPPESendKey);
            pPCB->pbMPPESendKey = NULL;
        }

        if (pPCB->pbMPPERecvKey != NULL)
        {
            FREE (pPCB->pbMPPERecvKey);
            pPCB->pbMPPERecvKey = NULL;
        }
    }

    return( dwRetCode );

}


//
// ElProcessEapSuccess
//
// Description:
//
// Function called when an EAP_Success is received in any state
//
// Input arguments:
//  pPCB - Pointer to PCB for the port on which data is being processed
//  pEapolPkt - Pointer to EAPOL packet that was received
//              
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElProcessEapSuccess (
    IN EAPOL_PCB        *pPCB,
    IN EAPOL_PACKET     *pEapolPkt
    )
{
    GUID                    DeviceGuid;
    BOOLEAN                 fAuthenticateAndAuthorized = TRUE;
    EAPOL_PACKET_D8_D7      *pDummyHeader;
    DWORD                   dwRetCode = NO_ERROR;

    TRACE0 (EAPOL, "ElProcessEapSuccess: Got EAPCODE_Success");

    do
    {

        // Indicate to EAP=Dll to cleanup completed session
        if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
        {
            TRACE1 (EAPOL, "ProcessReceivedPacket: EapSuccess: Error in ElEapEnd = %ld",
                    dwRetCode);
            break;
        }

        if (pPCB->fRemoteEnd8021XD8)
        {
            fAuthenticateAndAuthorized = FALSE;

            pDummyHeader = (EAPOL_PACKET_D8_D7 *)((BYTE *)pEapolPkt - 2);

            switch (WireToHostFormat16(pDummyHeader->AuthResultCode))
            {
                case AUTH_Authorized:
                    fAuthenticateAndAuthorized = TRUE;
                    break;
                case AUTH_Unauthorized:
                    fAuthenticateAndAuthorized = FALSE;
                    break;
                default:
                    fAuthenticateAndAuthorized = FALSE;
                    break;
            }
        }

        if (fAuthenticateAndAuthorized)
        {
            TRACE0 (EAPOL, "ElProcessEapSuccess: Autho and Authen successful");

            // Complete remaining processing i.e. DHCP
            if ((dwRetCode = FSMAuthenticated (pPCB,
                                        pEapolPkt)) != NO_ERROR)
            {
                break;
            }

#ifndef EAPOL_SERVICE

            // Display change of status using sys tray balloon
            // on interface icon
            ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
            (VOID)EAPOLMANAuthenticationSucceeded (&DeviceGuid);

#endif
        }
        else
        {
            TRACE0 (EAPOL, "ElProcessEapSuccess: Autho and Authen failed");

            if ((dwRetCode = FSMHeld (pPCB)) != NO_ERROR)
            {
                break;
            }

#ifndef EAPOL_SERVICE

            // Display change of status using sys tray balloon
            // on interface icon
            ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
            (VOID)EAPOLMANAuthenticationFailed (&DeviceGuid, 0);
    
#endif
        }

    } 
    while (FALSE);

    return dwRetCode;
}


//
// ElProcessEapFail
//
// Description:
//
// Function called when an EAP_Fail is received in any state
//
// Input arguments:
//  pPCB - Pointer to PCB for the port on which data is being processed
//  pEapolPkt - Pointer to EAPOL packet that was received
//              
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElProcessEapFail (
    IN EAPOL_PCB        *pPCB,
    IN EAPOL_PACKET     *pEapolPkt
    )
{
    GUID        DeviceGuid;
    DWORD       dwRetCode = NO_ERROR;

    TRACE0 (EAPOL, "ElProcessEapFail: Got EAPCODE_Failure");

    do
    {
        // Indicate to EAP=Dll to cleanup completed session
        if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
        {
            TRACE1 (EAPOL, "ElProcessEapFail: EapFail: Error in ElEapEnd = %ld",
                    dwRetCode);
            break;
        }

        if ((dwRetCode = FSMHeld (pPCB)) != NO_ERROR)
        {
            break;
        }

#ifndef EAPOL_SERVICE

        // Display change of status using sys tray balloon
        // on interface icon
        ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
        (VOID)EAPOLMANAuthenticationFailed (&DeviceGuid, 0);

#endif

    } 
    while (FALSE);

    return dwRetCode;
}

#undef EAPOL_SERVICE