/*++

Copyright (c) 2000, Microsoft Corporation

Module Name:
    
    eluser.c


Abstract:

    The module deals with functions related to user interaction, user logon


Revision History:

    sachins, Apr 23 2000, Created

--*/


#include "pcheapol.h"
#pragma hdrstop

#define cszEapKeyRas   TEXT("Software\\Microsoft\\RAS EAP\\UserEapInfo")

#define cszEapValue TEXT("EapInfo")

#ifndef EAPOL_SERVICE
#define cszModuleName TEXT("wzcsvc.dll")
#else
#define cszModuleName TEXT("eapol.exe")
#endif


//
// ElSessionChangeHandler
//
// Description:
//
//  Function called to handle user session login/logoff/user-switching
//
// Arguments:
//  pEventData - SCM event data
//  dwEventType - SCM event type
//

VOID
ElSessionChangeHandler (
        PVOID       pEventData,
        DWORD       dwEventType
        )
{
    DWORD                   dwEventStatus = 0;
    BOOLEAN                 fDecrWorkerThreadCount = FALSE;
    LPTHREAD_START_ROUTINE  pUserRoutine = NULL;
    PVOID                   pvBuffer = NULL;
    EAPOL_ZC_INTF   ZCData;
    DWORD                   dwRetCode = NO_ERROR;

    do
    {
        if (g_hEventTerminateEAPOL == NULL)
        {
            dwRetCode = NO_ERROR;
            break;
        }
        if (( dwEventStatus = WaitForSingleObject (
                                    g_hEventTerminateEAPOL,
                                    0)) == WAIT_FAILED)
        {
            dwRetCode = GetLastError ();
            break;
        }
        if (dwEventStatus == WAIT_OBJECT_0)
        {
            dwRetCode = NO_ERROR;
            break;
        }
        if (!(g_dwModulesStarted & LOGON_MODULE_STARTED))
        {
            break;
        }

        InterlockedIncrement (&g_lWorkerThreads);

        fDecrWorkerThreadCount = TRUE;

        if (pEventData)
        {
            WTSSESSION_NOTIFICATION* pswtsi = (WTSSESSION_NOTIFICATION*)pEventData;
            DWORD dwSessionId = pswtsi->dwSessionId;
    
            switch (dwEventType)
            {
                case WTS_CONSOLE_CONNECT:
                case WTS_REMOTE_CONNECT:    
                    {
                        TRACE1 (USER,"ElSessionChangeHandler: CONNECT for session = (%ld)\n", 
                                dwSessionId);
                        pUserRoutine = ElUserLogonCallback;
                        break;
                    }							
			             
                case WTS_CONSOLE_DISCONNECT:
                case WTS_REMOTE_DISCONNECT:	
                    {
                        TRACE1 (USER,"ElSessionChangeHandler: DISCONNECT for session = (%ld)\n", 
                                dwSessionId);
                        pUserRoutine = ElUserLogoffCallback;
                        break;
                    }				        
    
                case WTS_SESSION_LOGON:
                    {											
                        TRACE1 (USER,"ElSessionChangeHandler: LOGON for session = (%ld)", 
                                dwSessionId);
                        pUserRoutine = ElUserLogonCallback;
                        break;
                    }						
					    	
                case WTS_SESSION_LOGOFF:
                    {
                        TRACE1 (USER,"ElSessionChangeHandler: LOGOFF for session=(%ld)", 
                                dwSessionId);
							    	
                        pUserRoutine = ElUserLogoffCallback;
                        break;
                    }
					    	
                default:	
                    break;
            }

            if (pUserRoutine == NULL)
            {
                break;
            }

            if ((pvBuffer = MALLOC (sizeof(DWORD))) == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }

            *((DWORD *)pvBuffer) = dwSessionId;

            if (!QueueUserWorkItem (
                (LPTHREAD_START_ROUTINE)pUserRoutine,
                pvBuffer,
                WT_EXECUTELONGFUNCTION))
            {
                dwRetCode = GetLastError();
                TRACE1 (DEVICE, "ElSessionChangeHandler: QueueUserWorkItem failed with error %ld",
                        dwRetCode);
	            break;
            }
            else
            {
                fDecrWorkerThreadCount = FALSE;
            }

        }
    }
    while (FALSE);

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

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


//
// ElUserLogonCallback
//
// Description:
//
// Callback function invoked whenever a user logs in
// Will initiate authentication process on all ports of LAN class
// Credentials for the user in case of EAP-TLS can be obtained by 
// acquiring user token
// For EAP-CHAP, WinLogon cerdentials will need to be supplied
//
// Arguments:
//  None. 
//

DWORD
WINAPI
ElUserLogonCallback (
        IN  PVOID       pvContext
        )
{

    DWORD       dwIndex = 0;
    EAPOL_PCB   *pPCB = NULL;
    BOOL        fSetCONNECTINGState = FALSE;
    EAPOL_ZC_INTF   ZCData;
    DWORD       dwRetCode = NO_ERROR;           

    TRACE1 (USER, "ElUserLogonCallback: UserloggedOn = %ld",
            g_fUserLoggedOn);

    do 
    {
        if (g_fUserLoggedOn)
        {
            TRACE0 (USER, "ElUserLogonCallback: User logon already detected, returning without processing");
            break;
        }

        if (pvContext == NULL)
        {
            break;
        }

        if (*((DWORD *)pvContext) != USER_SHARED_DATA->ActiveConsoleId)
        {
            TRACE1 (USER, "ElUserLogonCallback: Not active console id (%ld)",
                    *((DWORD *)pvContext));
            break;
        }

        // Check if UserModule is ready for notifications

        if (!g_fTrayIconReady)
        {
            if ((dwRetCode = ElCheckUserModuleReady ()) != NO_ERROR)
            {
                TRACE1 (USER, "ElUserLogonCallback: ElCheckUserModuleReady failed with error %ld",
                        dwRetCode);
                if (dwRetCode == ERROR_BAD_IMPERSONATION_LEVEL)
                {
                    break;
                }
            }
        }

        // Set global flag to indicate the user logged on
        g_fUserLoggedOn = TRUE;
        g_dwCurrentSessionId = *((DWORD *)pvContext);


        ACQUIRE_WRITE_LOCK (&(g_PCBLock));

        for (dwIndex = 0; dwIndex < PORT_TABLE_BUCKETS; dwIndex++)
        {
            for (pPCB = g_PCBTable.pPCBBuckets[dwIndex].pPorts;
                    pPCB != NULL;
                    pPCB = pPCB->pNext)
            {
                fSetCONNECTINGState = FALSE;
                ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

                switch (pPCB->dwEAPOLAuthMode)
                {
                    case EAPOL_AUTH_MODE_0:

                        if (pPCB->State == EAPOLSTATE_AUTHENTICATED)
                        {
                            if (pPCB->PreviousAuthenticationType ==
                                    EAPOL_UNAUTHENTICATED_ACCESS)
                            {
                                fSetCONNECTINGState = TRUE;
                            }
                        }
                        else
                        {
                            (VOID) ElEapEnd (pPCB);
                            fSetCONNECTINGState = TRUE;
                        }

                        break;

                    case EAPOL_AUTH_MODE_1:

                        (VOID) ElEapEnd (pPCB);
                        fSetCONNECTINGState = TRUE;

                        break;

                    case EAPOL_AUTH_MODE_2:

                        // Do nothing 

                        break;
                }

                if (!EAPOL_PORT_ACTIVE(pPCB))
                {
                    TRACE1 (USER, "ElUserLogonCallback: Port %ws not active",
                                            pPCB->pwszDeviceGUID);
                    fSetCONNECTINGState = FALSE;
                }

                // Set port to EAPOLSTATE_CONNECTING
            
                if (fSetCONNECTINGState)
                {
                    DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_USER_LOGON, pPCB->pwszFriendlyName);

                    // First send out EAPOL_Logoff message
                    if ((dwRetCode = FSMLogoff (pPCB, NULL)) 
                            != NO_ERROR)
                    {
                        TRACE1 (USER, "ElUserLogonCallback: Error in FSMLogoff = %ld",
                                dwRetCode);
                        dwRetCode = NO_ERROR;
                    }

                    pPCB->dwAuthFailCount = 0;

                    // With unauthenticated access flag set, port will always
                    // reauthenticate for logged on user

                    pPCB->PreviousAuthenticationType = 
                                EAPOL_UNAUTHENTICATED_ACCESS;

                    RELEASE_WRITE_LOCK (&(pPCB->rwLock));

                    // Restart authentication on the port
                    if ((dwRetCode = ElReStartPort (pPCB, 0, NULL)) != NO_ERROR)
                    {
                        TRACE1 (USER, "ElUserLogonCallback: MachineAuth: Error in ElReStartPort = %ld",
                                dwRetCode);
                        continue;
                    }
                }
                else
                {
                    RELEASE_WRITE_LOCK (&(pPCB->rwLock));
                    continue;
                }
            }
        }
    
        RELEASE_WRITE_LOCK (&(g_PCBLock));
    
        if (dwRetCode != NO_ERROR)
        {
            break;
        }
    
    } while (FALSE);

    TRACE1 (USER, "ElUserLogonCallback: completed with error %ld", dwRetCode);
        
    if (pvContext != NULL)
    {
        FREE (pvContext);
    }

    InterlockedDecrement (&g_lWorkerThreads);

    return 0;
}


//
// ElUserLogoffCallback
//
// Description:
//
// Callback function invoked whenever a user logs off 
// Will logoff from all ports which have authentication enabled
//
// Arguments:
//  None. 
//

DWORD
WINAPI
ElUserLogoffCallback (
        IN  PVOID       pvContext
        )
{
    DWORD           dwIndex = 0;
    EAPOL_PCB       *pPCB = NULL; 
    BOOL            fSetCONNECTINGState = FALSE;
    EAPOL_ZC_INTF   ZCData;
    DWORD           dwRetCode = NO_ERROR;

    do
    {
        if (!g_fUserLoggedOn)
        {
            TRACE0 (USER, "ElUserLogoffCallback: User logoff already called, returning without processing");
            break;
        }

        if (pvContext == NULL)
        {
            break;
        }

        if (g_dwCurrentSessionId != *((DWORD *)pvContext))
        {
            TRACE1 (USER, "ElUserLogoffCallback: Not active console id (%ld)",
                    *((DWORD *)pvContext));
            break;
        }

        // Reset global flag to indicate the user logged off
    
        g_fUserLoggedOn = FALSE;
        g_dwCurrentSessionId = 0xffffffff;

        // Reset User Module ready flag
        g_fTrayIconReady = FALSE;
    
        TRACE1 (USER, "ElUserLogoffCallback: UserloggedOff = %ld",
                g_fUserLoggedOn);

        ACQUIRE_WRITE_LOCK (&(g_PCBLock));

        for (dwIndex = 0; dwIndex < PORT_TABLE_BUCKETS; dwIndex++)
        {
            for (pPCB = g_PCBTable.pPCBBuckets[dwIndex].pPorts;
                    pPCB != NULL;
                    pPCB = pPCB->pNext)
            {
                fSetCONNECTINGState = FALSE;
                ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

                switch (pPCB->dwEAPOLAuthMode)
                {
                    case EAPOL_AUTH_MODE_0:

                        if (pPCB->State == EAPOLSTATE_AUTHENTICATED)
                        {
                            if (pPCB->PreviousAuthenticationType !=
                                    EAPOL_MACHINE_AUTHENTICATION)
                            {
                                fSetCONNECTINGState = TRUE;
                            }
                        }
                        else
                        {
                            (VOID) ElEapEnd (pPCB);
                            fSetCONNECTINGState = TRUE;
                        }

                        break;

                    case EAPOL_AUTH_MODE_1:

                        (VOID) ElEapEnd (pPCB);
                        fSetCONNECTINGState = TRUE;

                        break;

                    case EAPOL_AUTH_MODE_2:

                        // Do nothing 

                        break;
                }

                if (!EAPOL_PORT_ACTIVE(pPCB))
                {
                    TRACE1 (USER, "ElUserLogoffCallback: Port %ws not active",
                                            pPCB->pwszDeviceGUID);
                    fSetCONNECTINGState = FALSE;
                }

                // Set port to EAPOLSTATE_CONNECTING
                if (fSetCONNECTINGState)
                {
                    DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, 
                            EAPOL_USER_LOGOFF, pPCB->pwszFriendlyName);

                    // First send out EAPOL_Logoff message
                    if ((dwRetCode = FSMLogoff (pPCB, NULL)) 
                            != NO_ERROR)
                    {
                        TRACE1 (USER, "ElUserLogoffCallback: Error in FSMLogoff = %ld",
                                dwRetCode);
                        dwRetCode = NO_ERROR;
                    }

                    pPCB->dwAuthFailCount = 0;

                    // With Unauthenticated_access, port will always
                    // reauthenticate 
                    pPCB->PreviousAuthenticationType = 
                                EAPOL_UNAUTHENTICATED_ACCESS;

                    RELEASE_WRITE_LOCK (&(pPCB->rwLock));

                    // Restart authentication on the port
                    if ((dwRetCode = ElReStartPort (pPCB, 0, NULL)) 
                            != NO_ERROR)
                    {
                        TRACE1 (USER, "ElUserLogoffCallback: Error in ElReStartPort = %ld",
                                dwRetCode);
                        continue;
                    }
                }
                else
                {
                    RELEASE_WRITE_LOCK (&(pPCB->rwLock));
                    continue;
                }
            }
        }
        RELEASE_WRITE_LOCK (&(g_PCBLock));
    }
    while (FALSE);
    
    TRACE0 (USER, "ElUserLogoffCallback: completed");

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

    InterlockedDecrement (&g_lWorkerThreads);
    
    return 0;
}


//
// ElGetUserIdentity
//
// Description:
//
// Function called to initiate and get user identity on a particular 
// interface. The RasEapGetIdentity in the appropriate DLL is called
// with the necessary arguments.
// 
// Arguments:
//  pPCB - Pointer to PCB for the specific port/interface
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElGetUserIdentity (
        IN  EAPOL_PCB       *pPCB
        )
{
    HANDLE              hLib = NULL;
    RASEAPFREE          pFreeFunc = NULL;
    RASEAPGETIDENTITY pIdenFunc = NULL;
    DWORD               dwIndex = -1;
    DWORD               cbData = 0;
    PBYTE               pbAuthData = NULL;
    PBYTE               pbUserIn = NULL;
    DWORD               dwInSize = 0;
    BYTE                *pUserDataOut;
    DWORD               dwSizeOfUserDataOut;
    LPWSTR              lpwszIdentity = NULL;
    CHAR                *pszIdentity = NULL;
    HWND                hwndOwner = NULL;
    DWORD               dwFlags = 0;
    BYTE                *pbSSID = NULL;
    DWORD               dwSizeOfSSID = 0;
    EAPOL_STATE         TmpEAPOLState;
    EAPOL_EAP_UI_CONTEXT *pEAPUIContext = NULL;
    DWORD               dwRetCode = NO_ERROR;

    do 
    {
        TRACE0 (USER, "ElGetUserIdentity entered");

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (PORT, "ElGetUserIdentity: Port %ws not active",
                    pPCB->pwszDeviceGUID);
            // Port is not active, cannot do further processing on this port
            break;
        }

        if (pPCB->PreviousAuthenticationType != EAPOL_MACHINE_AUTHENTICATION)
        {
            // Get Access Token for user logged on interactively

            if (pPCB->hUserToken != NULL)
            {
                if (!CloseHandle (pPCB->hUserToken))
                {
                    dwRetCode = GetLastError ();
                    TRACE1 (USER, "ElGetUserIdentity: CloseHandle failed with error %ld",
                            dwRetCode);
                    break;
                }
            }
            pPCB->hUserToken = NULL;

            if ((dwRetCode = ElGetWinStationUserToken (g_dwCurrentSessionId, &pPCB->hUserToken)) != NO_ERROR)
            {
                TRACE1 (USER, "ElGetUserIdentity: ElGetWinStationUserToken failed with error (%ld)",
                    dwRetCode);
                dwRetCode = ERROR_NO_TOKEN;
                break;
            }

            //
            // Try to fetch user identity without sending request to 
            // user module. If not possible, send request to user module
            //

            if ((dwRetCode = ElGetUserIdentityOptimized (pPCB))
                        != ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION)
            {
                TRACE0 (USER, "ElGetUserIdentity: ElGetUserIdentityOptimized got identity without user module intervention");
                break;
            }

            if (!g_fTrayIconReady)
            {
                if ((dwRetCode = ElCheckUserModuleReady ()) != NO_ERROR)
                {
                    TRACE1 (USER, "ElGetUserIdentity: ElCheckUserModuleReady failed with error %ld",
                            dwRetCode);
                    break;
                }
            }

            if (!g_fTrayIconReady)
            {
                DbLogPCBEvent (DBLOG_CATEG_WARN, pPCB, EAPOL_WAITING_FOR_DESKTOP_LOAD);
                dwRetCode = ERROR_IO_PENDING;
                TRACE0 (USER, "ElGetUserIdentity: TrayIcon NOT ready");
                break;
            }

            // 
            // Call GetUserIdentityDlgWorker
            //

            pEAPUIContext = MALLOC (sizeof(EAPOL_EAP_UI_CONTEXT));
            if (pEAPUIContext == NULL)
            {
                TRACE0 (USER, "ElGetUserIdentity: MALLOC failed for pEAPUIContext");
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }

            pEAPUIContext->dwEAPOLUIMsgType = EAPOLUI_GET_USERIDENTITY;
            wcscpy (pEAPUIContext->wszGUID, pPCB->pwszDeviceGUID);
            pPCB->dwUIInvocationId              =
                    InterlockedIncrement(&(g_dwEAPUIInvocationId));
            pEAPUIContext->dwSessionId = g_dwCurrentSessionId;
            pEAPUIContext->dwContextId = pPCB->dwUIInvocationId;
            pEAPUIContext->dwEapId = pPCB->bCurrentEAPId;
            pEAPUIContext->dwEapTypeId = pPCB->dwEapTypeToBeUsed;
            pEAPUIContext->dwEapFlags = pPCB->dwEapFlags;
            if (pPCB->pwszSSID)
            {
                wcscpy (pEAPUIContext->wszSSID, pPCB->pwszSSID);
            }
            if (pPCB->pSSID)
            {
                pEAPUIContext->dwSizeOfSSID = pPCB->pSSID->SsidLength;
                memcpy ((BYTE *)pEAPUIContext->bSSID, (BYTE *)pPCB->pSSID->Ssid,
                        NDIS_802_11_SSID_LEN-sizeof(ULONG));
            }

            // Have to notify state change before we post balloon
            TmpEAPOLState = pPCB->State;
            pPCB->State = EAPOLSTATE_ACQUIRED;
            ElNetmanNotify (pPCB, EAPOL_NCS_CRED_REQUIRED, NULL);
            // State is changed only in FSMAcquired
            // Revert to original
            pPCB->State = TmpEAPOLState;

            // Post the message to netman

            if ((dwRetCode = ElPostShowBalloonMessage (
                            pPCB,
                            sizeof(EAPOL_EAP_UI_CONTEXT),
                            (BYTE *)pEAPUIContext,
                            0,
                            NULL
                            )) != NO_ERROR)
            {
                TRACE1 (USER, "ElGetUserIdentity: ElPostShowBalloonMessage failed with error %ld",
                        dwRetCode);
                break;
            }

            // Restart PCB timer since UI may take longer time than required

            RESTART_TIMER (pPCB->hTimer,
                    INFINITE_SECONDS, 
                    "PCB",
                    &dwRetCode);
            if (dwRetCode != NO_ERROR)
            {
                break;
            }

            pPCB->EapUIState = EAPUISTATE_WAITING_FOR_IDENTITY;
            DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_WAITING_FOR_DESKTOP_IDENTITY);

            // Return error code as pending, since credentials have still not
            // been acquired
            dwRetCode = ERROR_IO_PENDING;

        }
        else // MACHINE_AUTHENTICATION
        {

        pPCB->hUserToken = NULL;

        // The EAP dll will have already been loaded by the state machine
        // Retrieve the handle to the dll from the global EAP table

        if ((dwIndex = ElGetEapTypeIndex (pPCB->dwEapTypeToBeUsed)) == -1)
        {
            TRACE1 (USER, "ElGetUserIdentity: ElGetEapTypeIndex finds no dll for EAP index %ld",
                    pPCB->dwEapTypeToBeUsed);
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }

        hLib = g_pEapTable[dwIndex].hInstance;

        pIdenFunc = (RASEAPGETIDENTITY)GetProcAddress(hLib, 
                                                    "RasEapGetIdentity");
        pFreeFunc = (RASEAPFREE)GetProcAddress(hLib, "RasEapFreeMemory");

        if ((pFreeFunc == NULL) || (pIdenFunc == NULL))
        {
            TRACE0 (USER, "ElGetUserIdentity: pIdenFunc or pFreeFunc does not exist in the EAP implementation");
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }

        if (pPCB->pSSID)
        {
            pbSSID = pPCB->pSSID->Ssid;
            dwSizeOfSSID = pPCB->pSSID->SsidLength;
        }

        // Get the size of the EAP blob
        if ((dwRetCode = ElGetCustomAuthData (
                        pPCB->pwszDeviceGUID,
                        pPCB->dwEapTypeToBeUsed,
                        dwSizeOfSSID,
                        pbSSID,
                        NULL,
                        &cbData
                        )) != NO_ERROR)
        {
            if (dwRetCode == ERROR_BUFFER_TOO_SMALL)
            {
                if (cbData <= 0)
                {
                    // No EAP blob stored in the registry
                    TRACE0 (USER, "ElGetUserIdentity: NULL sized EAP blob: continue");
                    pbAuthData = NULL;
                    // Every port should have connection data !!!
                    dwRetCode = NO_ERROR;
                }
                else
                {
                    // Allocate memory to hold the blob
                    pbAuthData = MALLOC (cbData);
                    if (pbAuthData == NULL)
                    {
                        dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                        TRACE0 (USER, "ElGetUserIdentity: Error in memory allocation for EAP blob");
                        break;
                    }
                    if ((dwRetCode = ElGetCustomAuthData (
                                pPCB->pwszDeviceGUID,
                                pPCB->dwEapTypeToBeUsed,
                                dwSizeOfSSID,
                                pbSSID,
                                pbAuthData,
                                &cbData
                                )) != NO_ERROR)
                    {
                        TRACE1 (USER, "ElGetUserIdentity: ElGetCustomAuthData failed with %ld",
                                dwRetCode);
                        break;
                    }
                }
            }
            else
            {
                // CustomAuthData for "Default" is always created for an
                // interface when EAPOL starts up
                TRACE1 (USER, "ElGetUserIdentity: ElGetCustomAuthData size estimation failed with error %ld",
                        dwRetCode);
                break;
            }
        }

        if (pIdenFunc)
        if ((dwRetCode = (*(pIdenFunc))(
                        pPCB->dwEapTypeToBeUsed,
                        hwndOwner, // hwndOwner
                        RAS_EAP_FLAG_MACHINE_AUTH, // dwFlags
                        NULL, // lpszPhonebook
                        pPCB->pwszFriendlyName, // lpszEntry
                        pbAuthData, // Connection data
                        cbData, // Count of pbAuthData
                        pbUserIn, // User data for port
                        dwInSize, // Size of user data
                        &pUserDataOut,
                        &dwSizeOfUserDataOut,
                        &lpwszIdentity
                        )) != NO_ERROR)
        {
            if (dwRetCode == ERROR_NO_EAPTLS_CERTIFICATE)
            {
                DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB, EAPOL_NO_CERTIFICATE_MACHINE);
            }
            else
            {
                DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB, EAPOL_ERROR_GET_IDENTITY, EAPOLAuthTypes[EAPOL_MACHINE_AUTHENTICATION], dwRetCode);
            }
            TRACE1 (USER, "ElGetUserIdentity: Error in calling GetIdentity = %ld",
                    dwRetCode);
            break;
        }

        // Fill in the returned information into the PCB fields for 
        // later authentication

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

        pPCB->pCustomAuthUserData = MALLOC (dwSizeOfUserDataOut + sizeof (DWORD));
        if (pPCB->pCustomAuthUserData == NULL)
        {
            TRACE1 (USER, "ElGetUserIdentity: Error in allocating memory for UserInfo = %ld",
                    dwRetCode);
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pPCB->pCustomAuthUserData->dwSizeOfCustomAuthData = dwSizeOfUserDataOut;

        if ((dwSizeOfUserDataOut != 0) && (pUserDataOut != NULL))
        {
            memcpy ((BYTE *)pPCB->pCustomAuthUserData->pbCustomAuthData, 
                (BYTE *)pUserDataOut, 
                dwSizeOfUserDataOut);
        }

        if (lpwszIdentity != NULL)
        {
            pszIdentity = MALLOC (wcslen(lpwszIdentity)*sizeof(CHAR) + sizeof(CHAR));
            if (pszIdentity == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (USER, "ElGetUserIdentity: MALLOC failed for pszIdentity");
                break;
            }

            if (0 == WideCharToMultiByte (
                        CP_ACP,
                        0,
                        lpwszIdentity,
                        -1,
                        pszIdentity,
                        wcslen(lpwszIdentity)*sizeof(CHAR)+sizeof(CHAR),
                        NULL, 
                        NULL ))
            {
                dwRetCode = GetLastError();
                TRACE2 (USER, "ElGetUserIdentity: WideCharToMultiByte (%ws) failed: %ld",
                        lpwszIdentity, dwRetCode);
                break;
            }

            TRACE1 (USER, "ElGetUserIdentity: Got identity = %s",
                    pszIdentity);

            if (pPCB->pszIdentity != NULL)
            {
                FREE (pPCB->pszIdentity);
                pPCB->pszIdentity = NULL;
            }
            pPCB->pszIdentity = MALLOC (strlen(pszIdentity) + sizeof(CHAR));
            if (pPCB->pszIdentity == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (USER, "ElGetUserIdentity: MALLOC failed for pPCB->pszIdentity");
                break;
            }
            memcpy (pPCB->pszIdentity, pszIdentity, strlen (pszIdentity));
            pPCB->pszIdentity[strlen(pszIdentity)] = '\0';
        }

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

        pPCB->pCustomAuthConnData = MALLOC (cbData + sizeof (DWORD));
        if (pPCB->pCustomAuthConnData == NULL)
        {
            TRACE1 (USER, "ElGetUserIdentity: Error in allocating memory for AuthInfo = %ld",
                    dwRetCode);
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pPCB->pCustomAuthConnData->dwSizeOfCustomAuthData = cbData;

        if ((cbData != 0) && (pbAuthData != NULL))
        {
            memcpy ((BYTE *)pPCB->pCustomAuthConnData->pbCustomAuthData, 
                (BYTE *)pbAuthData, 
                cbData);
        }

        // Mark the identity has been obtained for this PCB
        pPCB->fGotUserIdentity = TRUE;

        }

    } while (FALSE);

    // Cleanup
    if ((dwRetCode != NO_ERROR) && (dwRetCode != ERROR_IO_PENDING))
    {
        if (pPCB->pCustomAuthUserData != NULL)
        {
            FREE (pPCB->pCustomAuthUserData);
            pPCB->pCustomAuthUserData = NULL;
        }

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

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

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

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

    if (pFreeFunc != NULL)
    {
        if (lpwszIdentity != NULL)
        {
            if (( dwRetCode = (*(pFreeFunc)) ((BYTE *)lpwszIdentity)) != NO_ERROR)
            {
                TRACE1 (USER, "ElGetUserIdentity: Error in pFreeFunc = %ld",
                        dwRetCode);
            }
        }
        if (pUserDataOut != NULL)
        {
            if (( dwRetCode = (*(pFreeFunc)) ((BYTE *)pUserDataOut)) != NO_ERROR)
            {
                TRACE1 (USER, "ElGetUserIdentity: Error in pFreeFunc = %ld",
                        dwRetCode);
            }
        }
    }

    TRACE1 (USER, "ElGetUserIdentity completed with error %ld", dwRetCode);

    return dwRetCode;

}


//
// ElProcessUserIdentityResponse
//
// Description:
//
// Function to handle UI response for ElGetUserIdentityResponse
// 
// Arguments:
//
// Return values:
//
//

DWORD
ElProcessUserIdentityResponse (
        IN  EAPOL_EAP_UI_CONTEXT    EapolUIContext,
        IN  EAPOLUI_RESP            EapolUIResp
        )
{
    DWORD                   dwSizeOfIdentity = 0;
    BYTE                    *pbIdentity = NULL;
    DWORD                   dwSizeOfUserData = 0;
    BYTE                    *pbUserData = NULL;
    DWORD                   dwSizeofConnData = 0;
    BYTE                    *pbConnData = NULL;
    EAPOL_PCB               *pPCB = NULL;
    EAPOL_EAP_UI_CONTEXT    *pEAPUIContext = NULL;
    BOOLEAN                 fPortReferenced = FALSE;
    BOOLEAN                 fPCBLocked = FALSE;
    BOOLEAN                 fBlobCopyIncomplete = FALSE;
    DWORD                   dwRetCode = NO_ERROR;

    do
    {
        pEAPUIContext = (EAPOL_EAP_UI_CONTEXT *)&EapolUIContext;

        ACQUIRE_WRITE_LOCK (&g_PCBLock);

        if ((pPCB = ElGetPCBPointerFromPortGUID (pEAPUIContext->wszGUID)) != NULL)
        {
            if (EAPOL_REFERENCE_PORT (pPCB))
            {
                fPortReferenced = TRUE;
            }
            else
            {
                pPCB = NULL;
            }
        }

        RELEASE_WRITE_LOCK (&g_PCBLock);

        if (pPCB == NULL)
        {
            break;
        }

        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        fPCBLocked = TRUE;

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (USER, "ElProcessUserIdentityResponse: Port %ws not active",
                    pPCB->pwszDeviceGUID);

            // Port is not active, cannot do further processing on this port
            
            break;
        }

        if (pEAPUIContext->dwRetCode != NO_ERROR)
        {
            DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB,
                    EAPOL_ERROR_DESKTOP_IDENTITY, dwRetCode);
            TRACE1 (USER, "ElProcessUserIdentityResponse: Error in Dialog function (%ld)",
            pEAPUIContext->dwRetCode);
            break;
        }

        if (pPCB->EapUIState != EAPUISTATE_WAITING_FOR_IDENTITY)
        {
            TRACE2 (USER, "ElProcessUserIdentityResponse: PCB EapUIState has changed to (%ld), expected = (%ld)",
                    pPCB->EapUIState, EAPUISTATE_WAITING_FOR_IDENTITY);
            break;
        }

        if (pPCB->dwUIInvocationId != pEAPUIContext->dwContextId)
        {
            TRACE2 (USER, "ElProcessUserIdentityResponse: PCB UI Id has changed to (%ld), expected = (%ld)",
                    pPCB->dwUIInvocationId, pEAPUIContext->dwContextId);
            // break;
        }

        if (pPCB->bCurrentEAPId != pEAPUIContext->dwEapId)
        {
            TRACE2 (USER, "ElProcessUserIdentityResponse: PCB EAP Id has changed to (%ld), expected = (%ld)",
                    pPCB->bCurrentEAPId, pEAPUIContext->dwEapId);
            // break;
        }

        // Since the PCB context is right, restart PCB timer to timeout
        // in authPeriod seconds
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwauthPeriod,
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessUserIdentityResponse: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_PROCESSING_DESKTOP_RESPONSE);

        if ((EapolUIResp.rdData0.dwDataLen != 0) && (EapolUIResp.rdData0.pData != NULL))
        {
            dwSizeOfIdentity = EapolUIResp.rdData0.dwDataLen;
            pbIdentity = EapolUIResp.rdData0.pData;
        }

        if ((EapolUIResp.rdData1.dwDataLen != 0) && (EapolUIResp.rdData1.pData != NULL))
        {
            dwSizeOfUserData = EapolUIResp.rdData1.dwDataLen;
            pbUserData = EapolUIResp.rdData1.pData;
        }

        if ((EapolUIResp.rdData2.dwDataLen != 0) && (EapolUIResp.rdData2.pData != NULL))
        {
            dwSizeofConnData = EapolUIResp.rdData2.dwDataLen;
            pbConnData = EapolUIResp.rdData2.pData;
        }

        fBlobCopyIncomplete = TRUE;

        if (pPCB->pszIdentity != NULL)
        {
            FREE (pPCB->pszIdentity);
            pPCB->pszIdentity = NULL;
        }
        if (pbIdentity != NULL)
        {
            pPCB->pszIdentity = MALLOC (dwSizeOfIdentity + sizeof(CHAR));
            if (pPCB->pszIdentity == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (USER, "ElProcessUserIdentityResponse: MALLOC failed for pPCB->pszIdentity");
                break;
            }
            memcpy (pPCB->pszIdentity, pbIdentity, dwSizeOfIdentity);
            pPCB->pszIdentity[dwSizeOfIdentity] = '\0';
            TRACE1 (USER, "ElProcessUserIdentityResponse: Got username = %s",
                    pPCB->pszIdentity);
        }

        if (pPCB->pCustomAuthUserData != NULL)
        {
            FREE (pPCB->pCustomAuthUserData);
            pPCB->pCustomAuthUserData = NULL;
        }
        pPCB->pCustomAuthUserData = MALLOC (dwSizeOfUserData + sizeof (DWORD));
        if (pPCB->pCustomAuthUserData == NULL)
        {
            TRACE1 (USER, "ElProcessUserIdentityResponse: Error in allocating memory for UserInfo = %ld",
                    dwRetCode);
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }
        pPCB->pCustomAuthUserData->dwSizeOfCustomAuthData = dwSizeOfUserData;
        if ((dwSizeOfUserData != 0) && (pbUserData != NULL))
        {
            memcpy ((BYTE *)pPCB->pCustomAuthUserData->pbCustomAuthData, 
                (BYTE *)pbUserData, 
                dwSizeOfUserData);
        }

        if (pPCB->pCustomAuthConnData != NULL)
        {
            FREE (pPCB->pCustomAuthConnData);
            pPCB->pCustomAuthConnData = NULL;
        }
        pPCB->pCustomAuthConnData = MALLOC (dwSizeofConnData + sizeof (DWORD));
        if (pPCB->pCustomAuthConnData == NULL)
        {
            TRACE1 (USER, "ElProcessUserIdentityResponse: Error in allocating memory for AuthInfo = %ld",
                    dwRetCode);
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }
        pPCB->pCustomAuthConnData->dwSizeOfCustomAuthData = dwSizeofConnData;
        if ((dwSizeofConnData != 0) && (pbConnData != NULL))
        {
            memcpy ((BYTE *)pPCB->pCustomAuthConnData->pbCustomAuthData, 
                (BYTE *)pbConnData, 
                dwSizeofConnData);
        }

        fBlobCopyIncomplete = FALSE;

        if ((dwRetCode = ElCreateAndSendIdentityResponse (
                            pPCB, pEAPUIContext)) != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessUserIdentityResponse: ElCreateAndSendIdentityResponse failed with error %ld",
                    dwRetCode);
            break;
        }

        // Mark the identity has been obtained for this PCB
        pPCB->fGotUserIdentity = TRUE;

        // Reset the state if identity was obtained, else port will 
        // recover by itself
        pPCB->EapUIState &= ~EAPUISTATE_WAITING_FOR_IDENTITY;

    }
    while (FALSE);

    // Cleanup
    if (dwRetCode != NO_ERROR)
    {
        if (fPCBLocked && fBlobCopyIncomplete)
        {
            if (pPCB->pCustomAuthUserData != NULL)
            {
                FREE (pPCB->pCustomAuthUserData);
                pPCB->pCustomAuthUserData = NULL;
            }

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

    if (fPCBLocked)
    {
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
    }

    if (fPortReferenced)
    {
        EAPOL_DEREFERENCE_PORT (pPCB);
    }

    return dwRetCode;
}

    
//
// ElGetUserNamePassword
//
// Description:
//
// Function called to get username, domain (if any) and password using
// an interactive dialog. Called if EAP-type is MD5
//
// Arguments:
//      pPCB - Pointer to PCB for the port/interface on which credentials 
//      are to be obtained
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElGetUserNamePassword (
        IN  EAPOL_PCB       *pPCB
        )
{
    EAPOL_EAP_UI_CONTEXT    *pEAPUIContext = NULL;
    DWORD                   dwRetCode = NO_ERROR;

    do 
    {
        TRACE0 (USER, "ElGetUserNamePassword entered");

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (PORT, "ElGetUserNamePassword: Port %ws not active",
                    pPCB->pwszDeviceGUID);
            // Port is not active, cannot do further processing on this port
            break;
        }

        // Get Access Token for user logged on interactively
       
        if (pPCB->hUserToken != NULL)
        {
            if (!CloseHandle (pPCB->hUserToken))
            {
                dwRetCode = GetLastError ();
                TRACE1 (USER, "ElGetUserNamePassword: CloseHandle failed with error %ld",
                        dwRetCode);
                break;
            }
        }
        pPCB->hUserToken = NULL;

        if ((dwRetCode = ElGetWinStationUserToken (g_dwCurrentSessionId, &pPCB->hUserToken)) != NO_ERROR)
        {
            TRACE1 (USER, "ElGetUserNamePassword: ElGetWinStationUserToken failed with error (%ld)",
                dwRetCode);
            dwRetCode = ERROR_NO_TOKEN;
            break;
        }

        if (!g_fTrayIconReady)
        {
            if ((dwRetCode = ElCheckUserModuleReady ()) != NO_ERROR)
            {
                TRACE1 (USER, "ElGetUserNamePassword: ElCheckUserModuleReady failed with error %ld",
                        dwRetCode);
                break;
            }
        }

        if (!g_fTrayIconReady)
        {
            DbLogPCBEvent (DBLOG_CATEG_WARN, pPCB, EAPOL_WAITING_FOR_DESKTOP_LOAD);
            dwRetCode = ERROR_IO_PENDING;
            TRACE0 (USER, "ElGetUserNamePassword: TrayIcon NOT ready");
            break;
        }

        // 
        // Call ElGetUserNamePasswordDlgWorker
        //

        pEAPUIContext = MALLOC (sizeof(EAPOL_EAP_UI_CONTEXT));
        if (pEAPUIContext == NULL)
        {
            TRACE0 (USER, "ElGetUserNamePassword: MALLOC failed for pEAPUIContext");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pEAPUIContext->dwEAPOLUIMsgType = EAPOLUI_GET_USERNAMEPASSWORD;
        wcscpy (pEAPUIContext->wszGUID, pPCB->pwszDeviceGUID);
        pPCB->dwUIInvocationId              =
                InterlockedIncrement(&(g_dwEAPUIInvocationId));
        pEAPUIContext->dwSessionId = g_dwCurrentSessionId;
        pEAPUIContext->dwContextId = pPCB->dwUIInvocationId;
        pEAPUIContext->dwEapId = pPCB->bCurrentEAPId;
        pEAPUIContext->dwEapTypeId = pPCB->dwEapTypeToBeUsed;
        pEAPUIContext->dwEapFlags = pPCB->dwEapFlags;
        if (pPCB->pSSID)
        {
            memcpy ((BYTE *)pEAPUIContext->bSSID, (BYTE *)pPCB->pSSID->Ssid,
                    NDIS_802_11_SSID_LEN-sizeof(ULONG));
            pEAPUIContext->dwSizeOfSSID = pPCB->pSSID->SsidLength;
        }
        if (pPCB->pwszSSID)
        {
            wcscpy (pEAPUIContext->wszSSID, pPCB->pwszSSID);
        }

        // Post the message to netman

        if ((dwRetCode = ElPostShowBalloonMessage (
                        pPCB,
                        sizeof(EAPOL_EAP_UI_CONTEXT),
                        (BYTE *)pEAPUIContext,
                        0,
                        NULL
                        )) != NO_ERROR)
        {
            TRACE1 (USER, "ElGetUserNamePassword: ElPostShowBalloonMessage failed with error %ld",
                    dwRetCode);
            break;
        }

        // Restart PCB timer since UI may take longer time than required

        RESTART_TIMER (pPCB->hTimer,
                INFINITE_SECONDS, 
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            break;
        }

        pPCB->EapUIState = EAPUISTATE_WAITING_FOR_IDENTITY;
        DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_WAITING_FOR_DESKTOP_IDENTITY);

        // Return error code as pending, since credentials have still not
        // been acquired
        dwRetCode = ERROR_IO_PENDING;

    } while (FALSE);

    if ((dwRetCode != NO_ERROR) && (dwRetCode != ERROR_IO_PENDING))
    {
    }

    if (pEAPUIContext)
    {
        FREE (pEAPUIContext);
    }

    TRACE1 (USER, "ElGetUserNamePassword completed with error %ld", dwRetCode);

    return dwRetCode;
}


//
// ElProcessUserNamePasswordResponse
//
// Description:
//
// UI Response handler function for ElGetUserNamePassword
//
// Arguments:
//
// Return values:
//      NO_ERROR - success
//      non-zero - error
//

DWORD
ElProcessUserNamePasswordResponse (
        IN  EAPOL_EAP_UI_CONTEXT    EapolUIContext,
        IN  EAPOLUI_RESP            EapolUIResp
        )
{
    DWORD                   dwSizeOfIdentity = 0;
    BYTE                    *pbIdentity = NULL;
    DWORD                   dwSizeOfPassword = 0;
    BYTE                    *pbPassword = NULL;
    HWND                    hwndOwner = NULL;
    BOOLEAN                 fPCBLocked = FALSE;
    BOOLEAN                 fPortReferenced = FALSE;
    BOOLEAN                 fBlobCopyIncomplete = FALSE;
    EAPOL_PCB               *pPCB = NULL;
    EAPOL_EAP_UI_CONTEXT    *pEAPUIContext = NULL;
    DWORD                   dwRetCode = NO_ERROR;

    do 
    {
        TRACE0 (USER, "ElProcessUserNamePasswordResponse entered");

        pEAPUIContext = (EAPOL_EAP_UI_CONTEXT *)&EapolUIContext;

        ACQUIRE_WRITE_LOCK (&g_PCBLock);

        if ((pPCB = ElGetPCBPointerFromPortGUID (pEAPUIContext->wszGUID)) != NULL)
        {
            if (EAPOL_REFERENCE_PORT (pPCB))
            {
                fPortReferenced = TRUE;
            }
            else
            {
                pPCB = NULL;
            }
        }

        RELEASE_WRITE_LOCK (&g_PCBLock);

        if (pPCB == NULL)
        {
            break;
        }

        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        fPCBLocked = TRUE;

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (PORT, "ElProcessUserNamePasswordResponse: Port %ws not active",
                    pPCB->pwszDeviceGUID);
            // Port is not active, cannot do further processing on this port
            break;
        }
        
        if (pEAPUIContext->dwRetCode != NO_ERROR)
        {
            DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB,
                    EAPOL_ERROR_DESKTOP_IDENTITY, dwRetCode);
            TRACE1 (USER, "ElProcessUserNamePasswordResponse: Error in Dialog function (%ld)",
            pEAPUIContext->dwRetCode);
            break;
        }

        if (pPCB->EapUIState != EAPUISTATE_WAITING_FOR_IDENTITY)
        {
            TRACE2 (USER, "ElProcessUserNamePasswordResponse: PCB EapUIState has changed to (%ld), expected = (%ld)",
                    pPCB->EapUIState, EAPUISTATE_WAITING_FOR_IDENTITY);
            break;
        }

        if (pPCB->dwUIInvocationId != pEAPUIContext->dwContextId)
        {
            TRACE2 (USER, "ElProcessUserNamePasswordResponse: PCB UI Id has changed to (%ld), expected = (%ld)",
                    pPCB->dwUIInvocationId, pEAPUIContext->dwContextId);
            // break;
        }

        if (pPCB->bCurrentEAPId != pEAPUIContext->dwEapId)
        {
            TRACE2 (USER, "ElProcessUserNamePasswordResponse: PCB EAP Id has changed to (%ld), expected = (%ld)",
                    pPCB->bCurrentEAPId, pEAPUIContext->dwEapId);
            // break;
        }

        // Since the PCB context is right, restart PCB timer to timeout
        // in authPeriod seconds
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwauthPeriod,
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessUserNamePasswordResponse: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_PROCESSING_DESKTOP_RESPONSE);

        if ((EapolUIResp.rdData0.dwDataLen != 0) && (EapolUIResp.rdData0.pData != NULL))
        {
            dwSizeOfIdentity = EapolUIResp.rdData0.dwDataLen;
            pbIdentity = EapolUIResp.rdData0.pData;
        }

        if ((EapolUIResp.rdData1.dwDataLen != 0) && (EapolUIResp.rdData1.pData != NULL))
        {
            dwSizeOfPassword = EapolUIResp.rdData1.dwDataLen;
            pbPassword = EapolUIResp.rdData1.pData;
        }

        fBlobCopyIncomplete = TRUE;

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

        if  (pPCB->PasswordBlob.pbData != NULL)
        {
            FREE (pPCB->PasswordBlob.pbData);
            pPCB->PasswordBlob.pbData = NULL;
            pPCB->PasswordBlob.cbData = 0;
        }

        if (pbIdentity != NULL)
        {
            pPCB->pszIdentity = MALLOC (dwSizeOfIdentity + sizeof(CHAR));
            if (pPCB->pszIdentity == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                TRACE0 (USER, "ElProcessUserNamePasswordResponse: MALLOC failed for pPCB->pszIdentity");
                break;
            }
            memcpy (pPCB->pszIdentity, pbIdentity, dwSizeOfIdentity);
            pPCB->pszIdentity[dwSizeOfIdentity] = '\0';
            TRACE1 (USER, "ElProcessUserNamePasswordResponse: Got username = %s",
                    pPCB->pszIdentity);
        }

        if (pbPassword != 0)
        {
            if ((pPCB->PasswordBlob.pbData = 
                        MALLOC (dwSizeOfPassword)) == NULL)
            {
                dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
            memcpy (pPCB->PasswordBlob.pbData, pbPassword, dwSizeOfPassword);
            pPCB->PasswordBlob.cbData = dwSizeOfPassword;
        }

        fBlobCopyIncomplete = FALSE;

        if ((dwRetCode = ElCreateAndSendIdentityResponse (
                            pPCB, pEAPUIContext)) != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessUserNamePasswordResponse: ElCreateAndSendIdentityResponse failed with error %ld",
                    dwRetCode);
            break;
        }

        // Mark the identity has been obtained for this PCB
        pPCB->fGotUserIdentity = TRUE;

        // Reset the state if identity was obtained, else the port will recover
        // by itself
        pPCB->EapUIState &= ~EAPUISTATE_WAITING_FOR_IDENTITY;
       
    } while (FALSE);

    if (dwRetCode != NO_ERROR)
    {
        if (fPCBLocked && fBlobCopyIncomplete)
        {
            if (pPCB->pszIdentity)
            {
                FREE (pPCB->pszIdentity);
                pPCB->pszIdentity = NULL;
            }
            if (pPCB->PasswordBlob.pbData)
            {
                FREE (pPCB->PasswordBlob.pbData);
                pPCB->PasswordBlob.pbData = NULL;
                pPCB->PasswordBlob.cbData = 0;
            }
        }
    }

    if (fPCBLocked)
    {
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
    }

    if (fPortReferenced)
    {
        EAPOL_DEREFERENCE_PORT (pPCB);
    }

    TRACE1 (USER, "ElProcessUserNamePasswordResponse completed with error %ld", dwRetCode);

    return dwRetCode;
}


//
// ElInvokeInteractiveUI
//
// Description:
//
// Function called to invoke RasEapInvokeInteractiveUI for an EAP on a 
// particular interface
// 
// Arguments:
//  pPCB - Pointer to PCB for the specific interface
//  pInvokeEapUIIn - Data to be supplied to the InvokeInteractiveUI entrypoint
//      provided by the EAP dll through PPP_EAP_OUTPUT structure
//

DWORD
ElInvokeInteractiveUI (
        IN  EAPOL_PCB               *pPCB,
        IN  ELEAP_INVOKE_EAP_UI     *pInvokeEapUIIn
        )
{
    EAPOL_EAP_UI_CONTEXT    *pEAPUIContext = NULL;
    DWORD                   dwRetCode = NO_ERROR;

    do 
    {
        if (pInvokeEapUIIn == NULL)
        {
            dwRetCode = ERROR_INVALID_PARAMETER;
            return dwRetCode;
        }

        if (pPCB->PreviousAuthenticationType == EAPOL_MACHINE_AUTHENTICATION)
        {
            TRACE0 (USER, "ElInvokeInteractiveUI: Cannot popup UI during machine authentication");
            DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB, EAPOL_CANNOT_DESKTOP_MACHINE_AUTH);
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }
            
        if (!g_fTrayIconReady)
        {
            if ((dwRetCode = ElCheckUserModuleReady ()) != NO_ERROR)
            {
                TRACE1 (USER, "ElInvokeInteractiveUI: ElCheckUserModuleReady failed with error %ld",
                        dwRetCode);
                break;
            }
        }

        if (!g_fTrayIconReady)
        {
            DbLogPCBEvent (DBLOG_CATEG_WARN, pPCB, EAPOL_WAITING_FOR_DESKTOP_LOAD);
            dwRetCode = ERROR_IO_PENDING;
            TRACE0 (USER, "ElInvokeInteractiveUI: TrayIcon NOT ready");
            break;
        }

        TRACE0 (USER, "ElInvokeInteractiveUI entered");

        // 
        // Call ElInvokeInteractiveUIDlgWorker
        //

        pEAPUIContext = MALLOC (sizeof(EAPOL_EAP_UI_CONTEXT) +
                                    pInvokeEapUIIn->dwSizeOfUIContextData);
        if (pEAPUIContext == NULL)
        {
            TRACE0 (USER, "ElInvokeInteractiveUI: MALLOC failed for pEAPUIContext");
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pEAPUIContext->dwEAPOLUIMsgType = EAPOLUI_INVOKEINTERACTIVEUI;
        wcscpy (pEAPUIContext->wszGUID, pPCB->pwszDeviceGUID);
        pPCB->dwUIInvocationId              =
                InterlockedIncrement(&(g_dwEAPUIInvocationId));
        pEAPUIContext->dwSessionId = g_dwCurrentSessionId;
        pEAPUIContext->dwContextId = pPCB->dwUIInvocationId;
        pEAPUIContext->dwEapId = pPCB->bCurrentEAPId;
        pEAPUIContext->dwEapTypeId = pPCB->dwEapTypeToBeUsed;
        pEAPUIContext->dwEapFlags = pPCB->dwEapFlags;
        if (pPCB->pSSID)
        {
            pEAPUIContext->dwSizeOfSSID = pPCB->pSSID->SsidLength;
            memcpy ((BYTE *)pEAPUIContext->bSSID, (BYTE *)pPCB->pSSID->Ssid,
                    NDIS_802_11_SSID_LEN-sizeof(ULONG));
        }
        if (pPCB->pwszSSID)
        {
            wcscpy (pEAPUIContext->wszSSID, pPCB->pwszSSID);
        }
        pEAPUIContext->dwSizeOfEapUIData = 
            pInvokeEapUIIn->dwSizeOfUIContextData;
        memcpy (pEAPUIContext->bEapUIData, pInvokeEapUIIn->pbUIContextData,
                pInvokeEapUIIn->dwSizeOfUIContextData);

        // Post the message to netman

        if ((dwRetCode = ElPostShowBalloonMessage (
                        pPCB,
                        sizeof(EAPOL_EAP_UI_CONTEXT)+pInvokeEapUIIn->dwSizeOfUIContextData,
                        (BYTE *)pEAPUIContext,
                        0,
                        NULL
                        )) != NO_ERROR)
        {
            TRACE1 (USER, "ElInvokeInteractiveUI: ElPostShowBalloonMessage failed with error %ld",
                    dwRetCode);
            break;
        }

        // Restart PCB timer since UI may take longer time than required

        RESTART_TIMER (pPCB->hTimer,
                INFINITE_SECONDS, 
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            break;
        }

        pPCB->EapUIState = EAPUISTATE_WAITING_FOR_UI_RESPONSE;
        DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_WAITING_FOR_DESKTOP_LOGON);

        TRACE0 (USER, "ElInvokeInteractiveUI: ElEapWork completed successfully");

    } while (FALSE);

    if (pInvokeEapUIIn->pbUIContextData != NULL)
    {
        FREE (pInvokeEapUIIn->pbUIContextData);
        pInvokeEapUIIn->pbUIContextData = NULL;
        pInvokeEapUIIn->dwSizeOfUIContextData = 0;
    }

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

    TRACE1 (USER, "ElInvokeInteractiveUI completed with error %ld", dwRetCode);

    return dwRetCode;
}


//
// ElProcessInvokeInteractiveUIResponse
//
// Description:
//
// Worker function for ElInvokeInteractiveUI
// 
// Arguments:
//

DWORD
ElProcessInvokeInteractiveUIResponse (
        IN  EAPOL_EAP_UI_CONTEXT    EapolUIContext,
        IN  EAPOLUI_RESP            EapolUIResp
        )
{
    BYTE                    *pbUIData = NULL;
    DWORD                   dwSizeOfUIData = 0;
    EAPOL_PCB               *pPCB = NULL;
    EAPOL_EAP_UI_CONTEXT    *pEAPUIContext = NULL;
    BOOLEAN                 fPortReferenced = FALSE;
    BOOLEAN                 fPCBLocked = FALSE;
    DWORD                   dwRetCode = NO_ERROR;

    do 
    {
        TRACE0 (USER, "ElProcessInvokeInteractiveUIResponse entered");

        pEAPUIContext = (EAPOL_EAP_UI_CONTEXT *)&EapolUIContext;

        ACQUIRE_WRITE_LOCK (&g_PCBLock);

        if ((pPCB = ElGetPCBPointerFromPortGUID (pEAPUIContext->wszGUID)) != NULL)
        {
            if (EAPOL_REFERENCE_PORT (pPCB))
            {
                fPortReferenced = TRUE;
            }
            else
            {
                pPCB = NULL;
            }
        }

        RELEASE_WRITE_LOCK (&g_PCBLock);

        if (pPCB == NULL)
        {
            break;
        }

        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        fPCBLocked = TRUE;

        if (!EAPOL_PORT_ACTIVE(pPCB))
        {
            TRACE1 (PORT, "ElProcessInvokeInteractiveUIResponse: Port %ws not active",
                    pPCB->pwszDeviceGUID);
            break;
        }

        if (pEAPUIContext->dwRetCode != NO_ERROR)
        {
            DbLogPCBEvent (DBLOG_CATEG_ERR, pPCB, EAPOL_ERROR_DESKTOP_LOGON, dwRetCode);
            TRACE1 (USER, "ElProcessInvokeInteractiveUIResponse: Error in Dialog function (%ld)",
                pEAPUIContext->dwRetCode);
            break;
        }

        if (pPCB->EapUIState != EAPUISTATE_WAITING_FOR_UI_RESPONSE)
        {
            TRACE2 (USER, "ElProcessInvokeInteractiveUIResponse: PCB EapUIState has changed to (%ld), expected = (%ld)",
                    pPCB->EapUIState, EAPUISTATE_WAITING_FOR_UI_RESPONSE);
            break;
        }

        if (pPCB->dwUIInvocationId != pEAPUIContext->dwContextId)
        {
            TRACE2 (USER, "ElProcessInvokeInteractiveUIResponse: PCB UI Id has changed to (%ld), expected = (%ld)",
                    pPCB->dwUIInvocationId, pEAPUIContext->dwContextId);
            // break;
        }

        if (pPCB->bCurrentEAPId != pEAPUIContext->dwEapId)
        {
            TRACE2 (USER, "ElProcessInvokeInteractiveUIResponse: PCB EAP Id has changed to (%ld), expected = (%ld)",
                    pPCB->bCurrentEAPId, pEAPUIContext->dwEapId);
            // break;
        }

        // Since the PCB context is right, restart PCB timer to timeout
        // in authPeriod seconds
        RESTART_TIMER (pPCB->hTimer,
                pPCB->EapolConfig.dwauthPeriod,
                "PCB",
                &dwRetCode);
        if (dwRetCode != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessInvokeInteractiveUIResponse: Error in RESTART_TIMER %ld",
                    dwRetCode);
            break;
        }

        DbLogPCBEvent (DBLOG_CATEG_INFO, pPCB, EAPOL_PROCESSING_DESKTOP_RESPONSE);

        if ((EapolUIResp.rdData0.dwDataLen != 0) && (EapolUIResp.rdData0.pData != NULL))
        {
            dwSizeOfUIData = EapolUIResp.rdData0.dwDataLen;
            pbUIData = EapolUIResp.rdData0.pData;
        }

        if (pPCB->EapUIData.pEapUIData != NULL)
        {
            FREE (pPCB->EapUIData.pEapUIData);
            pPCB->EapUIData.pEapUIData = NULL;
            pPCB->EapUIData.dwSizeOfEapUIData = 0;
        }
        pPCB->EapUIData.pEapUIData = MALLOC (dwSizeOfUIData);
        if (pPCB->EapUIData.pEapUIData == NULL)
        {
            TRACE1 (USER, "ElProcessInvokeInteractiveUIResponse: Error in allocating memory for UIData = %ld",
                    dwRetCode);
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

        pPCB->EapUIData.dwSizeOfEapUIData = dwSizeOfUIData;
        if ((dwSizeOfUIData != 0) && (pbUIData != NULL))
        {
            memcpy ((BYTE *)pPCB->EapUIData.pEapUIData,
                (BYTE *)pbUIData, 
                dwSizeOfUIData);
        }

        pPCB->EapUIData.dwContextId = pPCB->dwUIInvocationId;

        pPCB->fEapUIDataReceived = TRUE;

        TRACE0 (USER, "ElProcessInvokeInteractiveUIResponse: Calling ElEapWork");

        // Provide UI data to EAP Dll for processing
        // EAP will send out response if required

        if ((dwRetCode = ElEapWork (
                                pPCB,
                                NULL)) != NO_ERROR)
        {
            TRACE1 (USER, "ElProcessInvokeInteractiveUIResponse: ElEapWork failed with error = %ld",
                    dwRetCode);
            break;
        }
                
        // Reset the state 
        pPCB->EapUIState &= ~EAPUISTATE_WAITING_FOR_UI_RESPONSE;

        TRACE0 (USER, "ElProcessInvokeInteractiveUIResponse: ElEapWork completed successfully");

    } while (FALSE);

    // Cleanup
    if (dwRetCode != NO_ERROR)
    {
        if (pPCB->EapUIData.pEapUIData != NULL)
        {
            FREE (pPCB->EapUIData.pEapUIData);
            pPCB->EapUIData.pEapUIData = NULL;
            pPCB->EapUIData.dwSizeOfEapUIData = 0;
        }
    }

    if (fPCBLocked)
    {
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
    }

    if (fPortReferenced)
    {
        EAPOL_DEREFERENCE_PORT (pPCB);
    }

    TRACE1 (USER, "ElProcessInvokeInteractiveUIResponse completed with error %ld", 
            dwRetCode);

    return dwRetCode;
}


//
// ElCreateAndSendIdentityResponse
//
// Description:
//
// Function called send out Identity Response packet
// 
// Arguments:
//  pPCB - Port Control Block for appropriate interface
//  pEAPUIContext - UI context blob
//
// Return values:
//  NO_ERROR -  success
//  !NO_ERROR - error
//
//

DWORD
ElCreateAndSendIdentityResponse (
        IN      EAPOL_PCB               *pPCB,
        IN      EAPOL_EAP_UI_CONTEXT    *pEAPUIContext
        )
{
    PPP_EAP_PACKET      *pSendBuf = NULL;
    EAPOL_PACKET        *pEapolPkt = NULL;
    WORD                wSizeOfEapPkt = 0;
    DWORD               dwIdentityLength = 0;
    DWORD               dwRetCode = NO_ERROR;

    do
    {
        // Create buffer for EAPOL + EAP and pass pointer to EAP header

        pEapolPkt = (EAPOL_PACKET *) MALLOC (MAX_EAPOL_BUFFER_SIZE); 

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

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

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

        pSendBuf->Code  = EAPCODE_Response;
        pSendBuf->Id    = (BYTE)pPCB->bCurrentEAPId;

        if (pPCB->pszIdentity != NULL)
        {
            dwIdentityLength = strlen (pPCB->pszIdentity);
        }
        else
        {
            dwIdentityLength = 0;
        }

        HostToWireFormat16 (
            (WORD)(PPP_EAP_PACKET_HDR_LEN+1+dwIdentityLength),
            pSendBuf->Length );

        strncpy ((CHAR *)pSendBuf->Data+1, (CHAR *)pPCB->pszIdentity, 
                dwIdentityLength);

        TRACE1 (EAPOL, "ElCreateAndSendIdResp: Identity sent out = %s", 
                pPCB->pszIdentity);

        pSendBuf->Data[0] = EAPTYPE_Identity;

        // Indicate to EAPOL what is length of the EAP packet
        wSizeOfEapPkt = (WORD)(PPP_EAP_PACKET_HDR_LEN+
                                    1+dwIdentityLength);

        // Send out EAPOL packet

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

        HostToWireFormat16 ((WORD) 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)+wSizeOfEapPkt-1);

        if (pPCB->pbPreviousEAPOLPkt == NULL)
        {
            dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
            break;
        }

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

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

        pPCB->dwPreviousId = pPCB->bCurrentEAPId;

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

    }
    while (FALSE);

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

    return dwRetCode;
}


//
// ElSendGuestIdentityResponse
//
// Description:
//
// Function called send out Guest Identity Response packet
// 
// Arguments:
//  pEAPUIContext - UI context blob
//
// Return values:
//  NO_ERROR    - success
//  !NO_ERROR   - failure
//

DWORD
ElSendGuestIdentityResponse (
        IN      EAPOL_EAP_UI_CONTEXT    *pEAPUIContext
        )
{
    EAPOL_PCB   *pPCB = NULL;
    BOOLEAN     fPortReferenced = FALSE;
    BOOLEAN     fPCBLocked = FALSE;
    DWORD       dwRetCode = NO_ERROR;

    do
    {
        ACQUIRE_WRITE_LOCK (&g_PCBLock);

        if ((pPCB = ElGetPCBPointerFromPortGUID (pEAPUIContext->wszGUID)) != NULL)
        {
            if (EAPOL_REFERENCE_PORT (pPCB))
            {
                fPortReferenced = TRUE;
            }
            else
            {
                pPCB = NULL;
            }
        }

        RELEASE_WRITE_LOCK (&g_PCBLock);

        if (pPCB == NULL)
        {
            break;
        }

        ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));

        fPCBLocked = TRUE;

        // Send the identity out as a EAP-Response packet

        if (pPCB->EapUIState != EAPUISTATE_WAITING_FOR_IDENTITY)
        {
            TRACE2 (USER, "ElSendGuestIdentityResponse: PCB EapUIState has changed to (%ld), expected = (%ld)",
                    pPCB->EapUIState, EAPUISTATE_WAITING_FOR_IDENTITY);
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }

        if (pPCB->dwUIInvocationId != pEAPUIContext->dwContextId)
        {
            TRACE2 (USER, "ElSendGuestIdentityResponse: PCB UI Id has changed to (%ld), expected = (%ld)",
                    pPCB->dwUIInvocationId, pEAPUIContext->dwContextId);
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }

        if (pPCB->bCurrentEAPId != pEAPUIContext->dwEapId)
        {
            TRACE2 (USER, "ElSendGuestIdentityResponse: PCB EAP Id has changed to (%ld), expected = (%ld)",
                    pPCB->bCurrentEAPId, pEAPUIContext->dwEapId);
            dwRetCode = ERROR_CAN_NOT_COMPLETE;
            break;
        }

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

        // Do not flag that identity was received
        // Reset the UI state though for state machine to proceed
        pPCB->EapUIState &= ~EAPUISTATE_WAITING_FOR_IDENTITY;
        pPCB->PreviousAuthenticationType = EAPOL_UNAUTHENTICATED_ACCESS;

        if ((dwRetCode = ElCreateAndSendIdentityResponse (
                            pPCB, pEAPUIContext)) != NO_ERROR)
        {
            TRACE1 (USER, "ElSendGuestIdentityResponse: ElCreateAndSendIdentityResponse failed with error %ld",
                    dwRetCode);
            break;
        }
    }
    while (FALSE);

    if (fPCBLocked)
    {
        RELEASE_WRITE_LOCK (&(pPCB->rwLock));
    }

    if (fPortReferenced)
    {
        EAPOL_DEREFERENCE_PORT (pPCB);
    }

    return dwRetCode;
}