able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/config/netman/eapol/service/eldeviceio.c

2489 lines
74 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 2000, Microsoft Corporation
Module Name:
eldeviceio.c
Abstract:
This module contains implementations for media-management and device I/O.
The routines declared here operate asynchronously on the handles
associated with an I/O completion port opened on the ndis uio driver.
Revision History:
sachins, Apr 23 2000, Created
--*/
#include "pcheapol.h"
#pragma hdrstop
// NDISUIO constants
CHAR NdisuioDevice[] = "\\\\.\\\\Ndisuio";
CHAR * pNdisuioDevice = &NdisuioDevice[0];
// TEST globals
PVOID g_QueryBinding;
PVOID g_TempBuf;
PVOID g_ItfBuffer;
PVOID g_Buf;
DWORD g_ItfBufferSize;
DWORD g_BreakAt;
extern
VOID
ElUserLogonDetection (
PVOID pvContext
);
//
// ElMediaInit
//
// Description:
//
// Called on EAPOL service startup to initialize all the media related events
// and callback functions
//
//
// Arguments:
//
// Return Values:
//
DWORD
ElMediaInit (
)
{
DWORD dwIndex = 0;
DWORD dwRetCode = NO_ERROR;
TRACE0 (INIT, "ElMediaInit: Entered");
do
{
// --ft:12/04/00: Initialize locks as the first thing to do. Otherwise, EAPOL registers
// with WMI and if a notification comes in before getting to initialize the lock this can
// result in an AV.
// Stress failure reported an AV on the following stack:
// ntdll!RtlpWaitForCriticalSection+0xb1 [z:\nt\base\ntdll\resource.c @ 1631]
// ntdll!RtlEnterCriticalSection+0x46 [Z:\nt\base\ntdll\i386\critsect.asm @ 157]
// netman!AcquireWriteLock+0xf [z:\nt\net\config\netman\eapol\service\elsync.c @ 137]
// netman!ElMediaSenseCallbackWorker+0x15c [z:\nt\net\config\netman\eapol\service\eldeviceio.c @ 937]
//
// The CRITICAL_SECTION looked like below:
// 75e226c4 00000000 00000001 00000000 00000000
// 75e226d4 00001990
//
// The (null) DebugInfo shows the object not being initialized successfully.
//
if (dwRetCode = CREATE_READ_WRITE_LOCK(&(g_ITFLock), "ITF") != NO_ERROR)
{
TRACE1(EAPOL, "ElMediaInit: Error (%ld) in creating g_ITFLock read-write-lock", dwRetCode);
break;
}
// Initialize NLA locks
if (dwRetCode = CREATE_READ_WRITE_LOCK(&(g_NLALock), "NLA") != NO_ERROR)
{
TRACE1(EAPOL, "ElMediaInit: Error (%ld) in creating g_NLALock read-write-lock", dwRetCode);
break;
}
// Register for Media Sense detection of MEDIA_CONNECT and
// MEDIA_DISCONNECT of interfaces
// This is done before anything else, so that no MEDIA events are lost
if ((dwRetCode = ElMediaSenseRegister (TRUE)) != NO_ERROR)
{
TRACE1(INIT, "ElMediaInit: ElMediaSenseRegister failed with dwRetCode = %d",
dwRetCode );
break;
}
else
{
g_dwModulesStarted |= WMI_MODULE_STARTED;
TRACE0(INIT, "ElMediaInit: ElMediaSenseRegister successful");
}
// Register for device notifications. We are interested in LAN
// interfaces coming and going.
if ((dwRetCode = ElDeviceNotificationRegister (TRUE)) != NO_ERROR)
{
TRACE1(INIT, "ElMediaInit: ElDeviceNotificationRegister failed with dwRetCode = %d",
dwRetCode );
break;
}
else
{
g_dwModulesStarted |= DEVICE_NOTIF_STARTED;
TRACE0(INIT, "ElMediaInit: ElDeviceNotificationRegister successful");
}
// Initialize EAPOL structures
if ((dwRetCode = ElInitializeEAPOL()) != NO_ERROR)
{
TRACE1(INIT, "ElMediaInit: ElInitializeEAPOL failed with dwRetCode = %d",
dwRetCode );
break;
}
else
{
TRACE0(INIT, "ElMediaInit: ElInitializeEAPOL successful");
g_dwModulesStarted |= EAPOL_MODULE_STARTED;
}
// Watch and update change in global registry parameters
if (!QueueUserWorkItem (
(LPTHREAD_START_ROUTINE)ElWatchGlobalRegistryParams,
NULL,
WT_EXECUTELONGFUNCTION))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElMediaInit: Critical error: QueueUserWorkItem failed for ElWatchGlobalRegistryParams with error %ld",
dwRetCode);
break;
}
// Watch changes in EAP config params by checking on
// ..\EAPOL\Interfaces key
if (!QueueUserWorkItem (
(LPTHREAD_START_ROUTINE)ElWatchEapConfigRegistryParams,
NULL,
WT_EXECUTELONGFUNCTION
))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElMediaInit: Critical error: QueueUserWorkItem failed for ElWatchEapConfigRegistryParams with error %ld",
dwRetCode);
break;
}
// Use task bar window for getting login notifications
if (!QueueUserWorkItem (
(LPTHREAD_START_ROUTINE)ElUserLogonDetection,
NULL,
WT_EXECUTELONGFUNCTION))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "Critical error: QueueUserWorkItem failed for ElUserLogonDetection with error %ld",
dwRetCode);
break;
}
// Initialize interface hash bucket table
g_ITFTable.pITFBuckets = (ITF_BUCKET *) MALLOC (INTF_TABLE_BUCKETS * sizeof (ITF_BUCKET));
if (g_ITFTable.pITFBuckets == NULL)
{
TRACE0 (DEVICE, "Error in allocation memory for ITF buckets");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
for (dwIndex=0; dwIndex < INTF_TABLE_BUCKETS; dwIndex++)
{
g_ITFTable.pITFBuckets[dwIndex].pItf=NULL;
}
ACQUIRE_WRITE_LOCK (&g_ITFLock)
// Enumerate all the interfaces and start EAPOL state machine
// on interfaces which are of LAN type
if ((dwRetCode = ElEnumAndOpenInterfaces (NULL, NULL)) != NO_ERROR)
{
TRACE1(INIT, "ElMediaInit: ElEnumAndOpenInterfaces failed with dwRetCode = %d",
dwRetCode );
RELEASE_WRITE_LOCK (&g_ITFLock);
break;
}
else
{
RELEASE_WRITE_LOCK (&g_ITFLock);
TRACE0(INIT, "ElMediaInit: ElEnumAndOpenInterfaces successful");
}
} while (FALSE);
if (dwRetCode == NO_ERROR)
{
TRACE0(INIT, "ElMediaInit successful");
}
else
{
}
return dwRetCode;
}
//
// ElMediaDeInit
//
// Description:
//
// Called on EAPOL service shutdown to de-initialize all the media
// related events and callback functions
//
//
// Arguments:
//
// Return Values:
//
DWORD
ElMediaDeInit (
)
{
DWORD dwRetCode = NO_ERROR;
TRACE0 (INIT, "ElMediaDeInit: Entered");
// DeRegister Media Sense detection of MEDIA_CONNECT and MEDIA_DISCONNECT
// of interfaces
if (g_dwModulesStarted & WMI_MODULE_STARTED)
{
if ((dwRetCode = ElMediaSenseRegister (FALSE)) != NO_ERROR )
{
TRACE1(INIT, "ElMediaDeInit: ElMediaSenseRegister failed with dwRetCode = %d",
dwRetCode );
// log
}
else
{
TRACE0(INIT, "ElMediaDeInit: ElMediaSenseRegister successful");
}
g_dwModulesStarted &= ~WMI_MODULE_STARTED;
}
// Deregister device notifications that may have been posted
if (g_dwModulesStarted & DEVICE_NOTIF_STARTED)
{
if ((dwRetCode = ElDeviceNotificationRegister (FALSE)) != NO_ERROR)
{
TRACE1(INIT, "ElMediaDeInit: ElDeviceNotificationRegister failed with dwRetCode = %d",
dwRetCode );
// log
}
else
{
TRACE0(INIT, "ElMediaDeInit: ElDeviceNotificationRegister successful");
}
g_dwModulesStarted &= ~DEVICE_NOTIF_STARTED;
}
// Shutdown EAPOL state machine
if (g_dwModulesStarted & EAPOL_MODULE_STARTED)
{
if ((dwRetCode = ElEAPOLDeInit()) != NO_ERROR)
{
TRACE1(INIT, "ElMediaDeInit: ElEAPOLDeInit failed with dwRetCode = %d",
dwRetCode );
// log
}
else
{
TRACE0(INIT, "ElMediaDeInit: ElEAPOLDeInit successful");
}
g_dwModulesStarted &= ~EAPOL_MODULE_STARTED;
}
// Free the interface table
if (READ_WRITE_LOCK_CREATED(&(g_ITFLock)))
{
ACQUIRE_WRITE_LOCK (&(g_ITFLock));
#if 0
if (!FREE(g_ITFTable.pITFBuckets))
{
TRACE0 (EAPOL, "ElMediaDeInit: Error in freeing ITF table memory");
dwRetCode = GetLastError();
}
#endif
FREE(g_ITFTable.pITFBuckets);
ZeroMemory (&g_ITFTable, sizeof (g_ITFTable));
RELEASE_WRITE_LOCK (&(g_ITFLock));
// Delete ITF table lock
DELETE_READ_WRITE_LOCK(&(g_ITFLock));
// Delete NLA lock
DELETE_READ_WRITE_LOCK(&(g_NLALock));
}
TRACE0(INIT, "ElMediaDeInit completed");
return dwRetCode;
}
//
// Description:
//
// Function called to register CallBack function with WMI
// for MEDIA_CONNECT/MEDIA_DISCONNECT events
//
// Arguments:
// fRegister - True = Register for Media Sense
// False = Deregister Media Sense requests
// Return values:
// NO_ERROR - Successful
// non-zero - Error
//
DWORD
ElMediaSenseRegister (
IN BOOL fRegister
)
{
DWORD dwRetCode = NO_ERROR;
PVOID pvDeliveryInfo = ElMediaSenseCallback;
dwRetCode = WmiNotificationRegistrationA(
(LPGUID)(&GUID_NDIS_STATUS_MEDIA_CONNECT),
(BOOLEAN)fRegister,
pvDeliveryInfo,
(ULONG_PTR)NULL,
NOTIFICATION_CALLBACK_DIRECT );
if (dwRetCode != NO_ERROR)
{
TRACE1(INIT, "ElMediaSenseRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_STATUS_MEDIA_CONNECT", dwRetCode);
return( dwRetCode );
}
dwRetCode = WmiNotificationRegistrationA(
(LPGUID)(&GUID_NDIS_STATUS_MEDIA_DISCONNECT),
(BOOLEAN)fRegister,
pvDeliveryInfo,
(ULONG_PTR)NULL,
NOTIFICATION_CALLBACK_DIRECT );
if (dwRetCode != NO_ERROR)
{
TRACE1(INIT, "ElMediaSenseRegister: Error %d in WmiNotificationRegistration:GUID_NDIS_STATUS_MEDIA_DISCONNECT", dwRetCode);
return( dwRetCode );
}
TRACE1 (INIT, "ElMediaSenseRegister - completed with RetCode %d", dwRetCode);
return( dwRetCode );
}
//
// ElDeviceNotificationRegister
//
// Description:
//
// Function called to register for device addition/removal notifications
//
// Arguments:
// fRegister - True = Register for Device Notifications
// False = Deregister Device Notifications
//
// Return values:
// NO_ERROR - Successful
// non-zero - Error
//
DWORD
ElDeviceNotificationRegister (
IN BOOL fRegister
)
{
HANDLE hDeviceNotification = NULL;
DWORD dwRetCode = NO_ERROR;
#ifdef EAPOL_SERVICE
DEV_BROADCAST_DEVICEINTERFACE PnPFilter;
ZeroMemory (&PnPFilter, sizeof(PnPFilter));
PnPFilter.dbcc_size = sizeof(PnPFilter);
PnPFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
PnPFilter.dbcc_classguid = GUID_NDIS_LAN_CLASS;
// NOTE:
// EAPOL service is only working with ANSI strings, hence the ANSI calls
hDeviceNotification = RegisterDeviceNotificationA(
(HANDLE)g_hServiceStatus,
&PnPFilter,
DEVICE_NOTIFY_SERVICE_HANDLE );
if (hDeviceNotification == NULL)
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElDeviceNotificationRegister failed with error %ld",
dwRetCode);
}
#endif
return dwRetCode;
}
//
// ElDeviceNotificationHandler
//
// Description:
//
// Function called to handle device notifications for interface addition/
// removal
//
// Arguments:
// lpEventData - interface information
// dwEventType - notification type
//
DWORD
ElDeviceNotificationHandler (
IN VOID *lpEventData,
IN DWORD dwEventType
)
{
DWORD dwEventStatus = 0;
DEV_BROADCAST_DEVICEINTERFACE *pInfo =
(DEV_BROADCAST_DEVICEINTERFACE *) lpEventData;
PVOID pvBuffer = NULL;
DWORD dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElDeviceNotificationHandler entered");
do
{
if (g_hEventTerminateEAPOL == NULL)
{
break;
}
// Check if have already gone through EAPOLCleanUp before
if ((dwEventStatus = WaitForSingleObject (
g_hEventTerminateEAPOL,
0)) == WAIT_FAILED)
{
dwRetCode = GetLastError ();
TRACE1(INIT, "ElDeviceNotificationHandler: WaitForSingleObject failed with error %ld, Terminating !!!",
dwRetCode);
// log
break;
}
if (dwEventStatus == WAIT_OBJECT_0)
{
TRACE0(INIT, "ElDeviceNotificationHandler: g_hEventTerminateEAPOL already signaled, returning");
break;
}
if (lpEventData == NULL)
{
dwRetCode = ERROR_INVALID_DATA;
TRACE0 (DEVICE, "ElDeviceNotificationHandler: lpEventData == NULL");
break;
}
if (pInfo->dbcc_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
{
TRACE0 (DEVICE, "ElDeviceNotificationHandler: Event for Interface type");
if ((pvBuffer = MALLOC (pInfo->dbcc_size + 8)) == NULL)
{
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
TRACE0 (DEVICE, "ElDeviceNotificationHandler: MALLOC failed for pvBuffer");
break;
}
*((DWORD *)pvBuffer) = dwEventType;
memcpy ((PBYTE)pvBuffer + 8, (PBYTE)pInfo, pInfo->dbcc_size);
if (!QueueUserWorkItem (
(LPTHREAD_START_ROUTINE)ElDeviceNotificationHandlerWorker,
pvBuffer,
WT_EXECUTELONGFUNCTION))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElDeviceNotificationHandler: QueueUserWorkItem failed with error %ld",
dwRetCode);
break;
}
}
else
{
TRACE0 (DEVICE, "ElDeviceNotificationHandler: Event NOT for Interface type");
}
}
while (FALSE);
TRACE1 (DEVICE, "ElDeviceNotificationHandler completed with error %ld",
dwRetCode);
if (dwRetCode != NO_ERROR)
{
if (pvBuffer != NULL)
{
FREE (pvBuffer);
}
}
return dwRetCode;
}
//
// ElDeviceNotificationHandlerWorker
//
// Description:
//
// Worker function for ElDeviceNotificationHandlerWorker
//
// Arguments:
// pvContext - interface information
//
VOID
ElDeviceNotificationHandlerWorker (
IN PVOID pvContext
)
{
EAPOL_PCB *pPCB = NULL;
EAPOL_ITF *pITF = NULL;
HANDLE hDevice = NULL;
DEV_BROADCAST_DEVICEINTERFACE *pInfo = NULL;
DWORD dwEventType = 0;
DWORD dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Entered");
do
{
if (pvContext == NULL)
{
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: pvContext == NULL");
break;
}
dwEventType = *((DWORD *) pvContext);
pInfo = (DEV_BROADCAST_DEVICEINTERFACE*)((PBYTE)pvContext + 8);
if ((dwEventType == DBT_DEVICEARRIVAL) ||
(dwEventType == DBT_DEVICEREMOVECOMPLETE))
{
// Extract GUID from the \Device\GUID string
WCHAR *pwszGUIDStart = NULL;
WCHAR *pwszGUIDEnd = NULL;
CHAR *pszGUIDStart = NULL;
WCHAR chGUIDSaveLast;
WCHAR Buffer1[256];
CHAR Buffer2[256];
UNICODE_STRING UnicodeGUID;
ANSI_STRING AnsiGUID;
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Interface arr/rem");
pwszGUIDStart = wcsrchr( pInfo->dbcc_name, L'{' );
pwszGUIDEnd = wcsrchr( pInfo->dbcc_name, L'}' );
if ((pwszGUIDStart != NULL) && (pwszGUIDEnd != NULL))
{
chGUIDSaveLast = *(pwszGUIDEnd+1);
// Ignore the leading '{' and the trailing '}'
// in the GUID
*(pwszGUIDEnd) = L'\0';
pwszGUIDStart ++;
UnicodeGUID.Buffer = Buffer1;
UnicodeGUID.MaximumLength = 256*sizeof(WCHAR);
RtlInitUnicodeString (&UnicodeGUID, pwszGUIDStart);
// Will not fail since memory is already allocated for the
// conversion
AnsiGUID.Buffer = Buffer2;
AnsiGUID.MaximumLength = 256;
RtlUnicodeStringToAnsiString (&AnsiGUID,
&UnicodeGUID, FALSE);
AnsiGUID.Buffer[AnsiGUID.Length] = '\0';
pszGUIDStart = AnsiGUID.Buffer;
TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: For interface %s",
pszGUIDStart);
// Interface was added
if (dwEventType == DBT_DEVICEARRIVAL)
{
ACQUIRE_WRITE_LOCK (&g_ITFLock);
TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device addition");
if ((dwRetCode = ElEnumAndOpenInterfaces (NULL,
pszGUIDStart))
!= NO_ERROR)
{
TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: ElEnumAndOpenInterfaces returned error %ld",
dwRetCode);
}
RELEASE_WRITE_LOCK (&g_ITFLock);
}
else
{
TRACE0(DEVICE, "ElDeviceNotificationHandlerWorker: Callback for device removal");
ACQUIRE_WRITE_LOCK (&(g_ITFLock));
// Check if EAPOL was actually started on this interface
// Verify by checking existence of corresponding
// entry in hash table
ACQUIRE_WRITE_LOCK (&(g_PCBLock));
if ((pPCB = ElGetPCBPointerFromPortGUID(pszGUIDStart))
!= NULL)
{
RELEASE_WRITE_LOCK (&(g_PCBLock));
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Found PCB entry for interface");
if ((pITF = ElGetITFPointerFromInterfaceDesc(
pPCB->pszFriendlyName))
== NULL)
{
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Did not find ITF entry when PCB exits, HOW BIZARRE !!!");
}
if ((dwRetCode = ElDeletePort (
pszGUIDStart,
&hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: Error in deleting port for %s",
pPCB->pszDeviceGUID);
}
//
// Remove interface entry from interface table
//
if (pITF != NULL)
{
ElRemoveITFFromTable(pITF);
if (pITF->pszInterfaceDesc)
{
FREE (pITF->pszInterfaceDesc);
}
if (pITF->pszInterfaceGUID)
{
FREE (pITF->pszInterfaceGUID);
}
if (pITF)
{
FREE (pITF);
}
}
// Close the handle to the NDISUIO driver
if (hDevice != NULL)
{
if ((dwRetCode = ElCloseInterfaceHandle (hDevice))
!= NO_ERROR)
{
TRACE1 (DEVICE,
"ElDeviceNotificationHandlerWorker: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
}
TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker: Port deleted %s",
pszGUIDStart);
}
else
{
RELEASE_WRITE_LOCK (&(g_PCBLock));
// Ignore device removal
//
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: ElGetPCBPointerFromPortGUID did not find any matching entry, ignoring DEVICE REMOVAL");
}
RELEASE_WRITE_LOCK (&g_ITFLock);
}
}
}
else
{
TRACE0 (DEVICE, "ElDeviceNotificationHandlerWorker: Event type is is NOT device arr/rem");
}
}
while (FALSE);
if (pvContext != NULL)
{
FREE (pvContext);
}
TRACE1 (DEVICE, "ElDeviceNotificationHandlerWorker completed with error %ld",
dwRetCode);
return;
}
//
// ElMediaSenseCallback
//
// Description:
//
// Callback function called by WMI on MEDIA_CONNECT/MEDIA_DISCONNECT
// events
//
// Arguments:
// pWnodeHeader - Pointer to information returned by the event
// uiNotificationContext - unused
//
// Return values:
// NO_ERROR - Success
// non-zero - Error
//
VOID
CALLBACK
ElMediaSenseCallback (
IN PWNODE_HEADER pWnodeHeader,
IN UINT_PTR uiNotificationContext
)
{
DWORD dwEventStatus = 0;
PVOID pvBuffer = NULL;
DWORD dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElMediaSenseCallback: Entered");
do
{
if (g_hEventTerminateEAPOL == NULL)
{
dwRetCode = NO_ERROR;
break;
}
// Check if have already gone through EAPOLCleanUp before
if (( dwEventStatus = WaitForSingleObject (
g_hEventTerminateEAPOL,
0)) == WAIT_FAILED)
{
dwRetCode = GetLastError ();
TRACE1 (INIT, "ElMediaSenseCallback: WaitForSingleObject failed with error %ld, Terminating !!!",
dwRetCode);
// log
break;
}
if (dwEventStatus == WAIT_OBJECT_0)
{
dwRetCode = NO_ERROR;
TRACE0 (INIT, "ElMediaSenseCallback: g_hEventTerminateEAPOL already signaled, returning");
break;
}
if (pWnodeHeader == NULL)
{
dwRetCode = ERROR_INVALID_DATA;
TRACE0 (DEVICE, "ElMediaSenseCallback: pWnodeHeader == NULL");
break;
}
if ((pvBuffer = MALLOC (pWnodeHeader->BufferSize)) == NULL)
{
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
TRACE0 (DEVICE, "ElMediaSenseCallback: MALLOC failed for pvBuffer");
break;
}
memcpy ((PVOID)pvBuffer, (PVOID)pWnodeHeader, pWnodeHeader->BufferSize);
if (!QueueUserWorkItem (
(LPTHREAD_START_ROUTINE)ElMediaSenseCallbackWorker,
pvBuffer,
WT_EXECUTELONGFUNCTION))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElMediaSenseCallback: QueueUserWorkItem failed with error %ld",
dwRetCode);
ASSERT (0);
}
}
while (FALSE);
if (dwRetCode != NO_ERROR)
{
TRACE1 (DEVICE, "ElMediaSenseCallback: Failed with error %ld",
dwRetCode);
if (pvBuffer != NULL)
{
FREE (pvBuffer);
}
}
}
//
// ElMediaSenseCallbackWorker
//
// Description:
//
// Worker function for ElMediaSenseCallback and executes in a separate
// thread
//
// Arguments:
// pvContext - Pointer to information returned by the media-sense event
//
// Return values:
// NO_ERROR - Success
// non-zero - Error
//
VOID
ElMediaSenseCallbackWorker (
IN PVOID pvContext
)
{
PWNODE_HEADER pWnodeHeader = (PWNODE_HEADER)pvContext;
PWNODE_SINGLE_INSTANCE pWnode = (PWNODE_SINGLE_INSTANCE)pWnodeHeader;
LPWSTR lpwsName;
CHAR *psName;
CHAR *psDeviceName = NULL;
CHAR psLength;
USHORT cpsLength;
CHAR *psNameEnd;
LPWSTR lpwsDeviceName = NULL;
HANDLE hDevice = NULL;
UNICODE_STRING uInterfaceDescription;
ANSI_STRING InterfaceDescription;
PCHAR pszInterfaceDescription;
UCHAR Buffer[256];
CHAR *pszInterfaceDesc = NULL;
DWORD dwIndex;
EAPOL_ITF *pITF;
ULONG i = 0;
EAPOL_PCB *pPCB = NULL;
DWORD dwRetCode = NO_ERROR;
do
{
#ifdef EAPOL_SERVICE
if ((g_ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
||
(g_ServiceStatus.dwCurrentState == SERVICE_STOPPED))
{
TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Callback received while service was stopping");
break;
}
#endif // EAPOL_SERVICE
if (pWnodeHeader == NULL)
{
TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Callback received with NULL NDIS interface details");
break;
}
psName = (PCHAR)RtlOffsetToPointer(
pWnode,
pWnode->OffsetInstanceName );
// Get the length of the string
// Null terminate it
cpsLength = (SHORT)( *((SHORT *)psName) );
if (!(psDeviceName = (CHAR *) MALLOC ((cpsLength+1)*sizeof(CHAR))))
{
TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Error in Memory allocation for psDeviceName");
break;
}
memcpy ((CHAR *)psDeviceName, (CHAR *)psName+sizeof(SHORT), cpsLength);
psDeviceName[cpsLength] = '\0';
RtlInitAnsiString (&InterfaceDescription, psDeviceName);
InterfaceDescription.Buffer[cpsLength] = '\0';
TRACE3(DEVICE, "ElMediaSenseCallbackWorker: For interface ANSI %s, true= %s, lengt of block = %d",
InterfaceDescription.Buffer, psDeviceName, cpsLength);
pszInterfaceDescription = InterfaceDescription.Buffer;
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Interface desc = %s",
pszInterfaceDescription);
//
// Get the information for the media disconnect.
//
if (memcmp( &(pWnodeHeader->Guid),
&GUID_NDIS_STATUS_MEDIA_DISCONNECT,
sizeof(GUID)) == 0)
{
// MEDIA DISCONNECT callback
TRACE0(DEVICE, "ElMediaSenseCallbackWorker: Callback for sense disconnect");
ACQUIRE_WRITE_LOCK (&(g_ITFLock))
// Check if EAPOL was actually started on this interface
// Verify by checking existence of corresponding entry in hash table
if ((pITF = ElGetITFPointerFromInterfaceDesc(pszInterfaceDescription))
!= NULL)
{
TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: Found ITF entry for interface");
#if 0
if ((dwRetCode = ElDeletePort (pITF->pszInterfaceGUID, &hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Error in deleting port for %s",
pITF->pszInterfaceGUID);
}
// Remove interface entry from interface table
ElRemoveITFFromTable(pITF);
if (pITF->pszInterfaceDesc)
{
FREE (pITF->pszInterfaceDesc);
pITF->pszInterfaceDesc = NULL;
}
if (pITF->pszInterfaceGUID)
{
FREE (pITF->pszInterfaceGUID);
pITF->pszInterfaceGUID = NULL;
}
if (pITF)
{
FREE (pITF);
pITF = NULL;
}
// Close the handle to the NDISUIO driver
if ((dwRetCode = ElCloseInterfaceHandle (hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE,
"ElMediaSenseCallbackWorker: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Port deleted %s",
pszInterfaceDescription);
#endif
ACQUIRE_WRITE_LOCK (&(g_PCBLock));
pPCB = ElGetPCBPointerFromPortGUID (pITF->pszInterfaceGUID);
if (pPCB != NULL)
{
ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
if ((dwRetCode = FSMDisconnected (pPCB)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: FSMDisconnected failed with error %ld",
dwRetCode);
}
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
}
RELEASE_WRITE_LOCK (&(g_PCBLock));
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: Port marked disconnected %s",
pszInterfaceDescription);
}
else
{
// Ignore MEDIA DISCONNECT
TRACE0 (DEVICE, "ElMediaSenseCallbackWorker: ElHashInterfaceDescToBucket did not find any matching entry, ignoring MEDIA_DISCONNECT");
}
RELEASE_WRITE_LOCK (&g_ITFLock);
}
else
{
if (memcmp( &(pWnodeHeader->Guid),
&GUID_NDIS_STATUS_MEDIA_CONNECT,
sizeof(GUID)) == 0)
{
// MEDIA CONNECT callback
ACQUIRE_WRITE_LOCK (&g_ITFLock)
TRACE0(DEVICE, "ElMediaSenseCallbackWorker: Callback for sense connect");
if ((dwRetCode = ElEnumAndOpenInterfaces (
pszInterfaceDescription, NULL))
!= NO_ERROR)
{
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: ElEnumAndOpenInterfaces returned error %ld",
dwRetCode);
}
RELEASE_WRITE_LOCK (&g_ITFLock);
}
}
}
while (FALSE);
TRACE1 (DEVICE, "ElMediaSenseCallbackWorker: processed, RetCode = %ld", dwRetCode);
if (pWnodeHeader != NULL)
{
FREE (pWnodeHeader);
}
if (psDeviceName != NULL)
{
FREE (psDeviceName);
}
return;
}
//
// ElEnumAndOpenInterfaces
//
// Description:
//
// Enumerates interfaces and intializes EAPOL on desired ones.
//
// If EAPOL is to be started on an interface, it opens a handle to
// the NDISUIO driver, calls EAPOL to create and initialize PCB for the
// interface, and finally adds an entry to the interface hashtable.
//
// If pszDesiredGUID is not NULL, all interfaces are enumerated, but
// EAPOL will be initialized only on the interface whose GUID matches.
//
// If pszDescription is not NULL, all interfaces are enumerated, but
// EAPOL will be initialized only on the interface whose description matches.
//
// If pszDesiredGUID and pszDescription are both NULL, all interfaces are
// enumerated. EAPOL will be initialized only on all interfaces that
// does have an entry in the interface hashtable.
//
//
// Arguments:
// pszDesiredDescription - Interface Description on which EAPOL is to
// be started
// pszDesiredGUID - Interface GUID on which EAPOL is to be started
//
// Return values:
// NO_ERROR - Success
// non-zero - Error
//
DWORD
ElEnumAndOpenInterfaces (
CHAR *pszDesiredDescription,
CHAR *pszDesiredGUID
)
{
CHAR EnumerateBuffer[256];
PNDIS_ENUM_INTF Interfaces = NULL;
BYTE *pbNdisuioEnumBuffer = NULL;
DWORD dwNdisuioEnumBufferSize = 0;
DWORD dwNicCardStatus = 0;
DWORD dwMediaType = 0;
HANDLE hDevice = NULL;
EAPOL_ITF *pNewITF = NULL;
DWORD dwIndex = 0;
UCHAR csCurrMacAddress[6];
UCHAR csPermMacAddress[6];
UCHAR csOidVendData[16];
BOOL fSearchByDescription = FALSE;
BOOL fSearchByGUID = FALSE;
DWORD dwEapTypeToBeUsed = DEFAULT_EAP_TYPE;
DWORD dwEapolEnabled = DEFAULT_EAPOL_STATE;
CHAR csDummyBuffer[256];
UNICODE_STRING TempUString;
CHAR *pszGUIDStart = NULL;
EAPOL_PCB *pPCB = NULL;
BOOL fPCBExists = FALSE;
DWORD dwAvailableInterfaces = 0;
DWORD dwRetCode = NO_ERROR;
TRACE2 (DEVICE, "ElEnumAndOpenInterfaces: DeviceDesc = %s, GUID = %s",
pszDesiredDescription, pszDesiredGUID);
if (pszDesiredGUID == NULL)
{
if (pszDesiredDescription != NULL)
{
fSearchByDescription = TRUE;
}
}
else
{
if (pszDesiredDescription != NULL)
{
return ERROR;
}
fSearchByGUID = TRUE;
}
ZeroMemory (EnumerateBuffer, 256);
Interfaces = (PNDIS_ENUM_INTF)EnumerateBuffer;
//
// Allocate amount of memory as instructed by NdisEnumerateInterfaces
// once the API allows querying of bytes required
//
Interfaces->TotalInterfaces = 0;
Interfaces->AvailableInterfaces = 0;
Interfaces->BytesNeeded = 0;
if (!NdisEnumerateInterfaces(Interfaces, 256))
{
dwRetCode = GetLastError ();
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: NdisEnumerateInterfaces failed with error %ld",
dwRetCode);
return dwRetCode;
}
TRACE3 (DEVICE, "ElEnumAndOpenInterfaces: TotalInterfaces = %ld, AvailInt = %ld, Bytes needed = %ld",
Interfaces->TotalInterfaces,
Interfaces->AvailableInterfaces,
Interfaces->BytesNeeded);
dwAvailableInterfaces = Interfaces->AvailableInterfaces;
dwNdisuioEnumBufferSize = (Interfaces->BytesNeeded + 7) & ~7;
if (dwNdisuioEnumBufferSize == 0) {
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: MALLOC skipped for zero length pbNdisuioEnumBuffer");
dwRetCode = NO_ERROR;
return dwRetCode;
}
pbNdisuioEnumBuffer = (BYTE *) MALLOC (4*dwNdisuioEnumBufferSize);
if (pbNdisuioEnumBuffer == NULL)
{
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: MALLOC failed for pbNdisuioEnumBuffer");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
return dwRetCode;
}
Interfaces = (PNDIS_ENUM_INTF)pbNdisuioEnumBuffer;
// Enumerate all the interfaces present on the machine
if ((dwRetCode = ElNdisuioEnumerateInterfaces (
Interfaces,
dwAvailableInterfaces,
4*dwNdisuioEnumBufferSize)) == NO_ERROR)
{
ANSI_STRING InterfaceName;
ANSI_STRING InterfaceDescription;
UNICODE_STRING UInterfaceName;
UCHAR Buffer1[256];
UCHAR Buffer2[256];
WCHAR Buffer3[256];
DWORD i;
InterfaceName.MaximumLength = 256;
InterfaceName.Buffer = Buffer1;
InterfaceDescription.MaximumLength = 256;
InterfaceDescription.Buffer = Buffer2;
TRACE1 (DEVICE, "TotalInterfaces=%ld", Interfaces->TotalInterfaces);
// Update the interface list in the registry that NDISUIO has bound to.
// The current interface list is just overwritten into the registry.
if ((dwRetCode = ElUpdateRegistryInterfaceList (Interfaces))
!= NO_ERROR)
{
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: ElUpdateInterfaceList failed with error =%ld",
dwRetCode);
// log
}
for (i=0; i < Interfaces->TotalInterfaces; i++)
{
if (Interfaces->Interface[i].DeviceName.Buffer != NULL)
{
InterfaceName.Length = 0;
InterfaceName.MaximumLength = 256;
if (RtlUnicodeStringToAnsiString(&InterfaceName,
&Interfaces->Interface[i].DeviceName, FALSE) != STATUS_SUCCESS)
{
TRACE0 (INIT, "Error in RtlUnicodeStringToAnsiString for DeviceName");
}
InterfaceName.Buffer[InterfaceName.Length] = '\0';
}
else
{
TRACE0(INIT, "NdisEnumerateInterfaces: Device Name was NULL");
continue;
}
TRACE1(INIT, "Device: %s", InterfaceName.Buffer);
// BUBUG:
// Should Device Name be retained in Unicode or converted to ANSI
InterfaceDescription.Length = 0;
InterfaceDescription.MaximumLength = 256;
if (RtlUnicodeStringToAnsiString(&InterfaceDescription,
&Interfaces->Interface[i].DeviceDescription, FALSE) != STATUS_SUCCESS)
{
TRACE0 (INIT, "Error in RtlUnicodeStringToAnsiString for DeviceDescription");
}
InterfaceDescription.Buffer[InterfaceDescription.Length] = '\0';
TRACE1(INIT, "Description: %s", InterfaceDescription.Buffer);
// Create PCB for interface and start EAPOL state machine
// EAPOL requested be started only a particular
// interface
if (fSearchByDescription)
{
if (strcmp (InterfaceDescription.Buffer,
pszDesiredDescription)
!= 0)
{
// No match, continue with next interface
continue;
}
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %s", InterfaceDescription.Buffer);
}
if (fSearchByGUID)
{
if (strstr (InterfaceName.Buffer,
pszDesiredGUID)
== NULL)
{
// No match, continue with next interface
continue;
}
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Found interface after enumeration %s", InterfaceName.Buffer);
}
{
// Extract GUID-string out of device name
CHAR *pszGUIDEnd;
CHAR *pszGUID;
CHAR chGUIDSaveLast;
pszGUID = InterfaceName.Buffer;
pszGUIDStart = strchr( pszGUID, '{' );
pszGUIDEnd = strchr( pszGUID, '}' );
if (RtlAnsiStringToUnicodeString (
&TempUString,
&InterfaceName,
TRUE))
{
TRACE0 (DEVICE, "Error in RtlAnsiStringToUnicodeString for TempUString");
}
// Query MAC address for the interface
if (!NdisQueryHwAddress (
&TempUString,
csCurrMacAddress,
csPermMacAddress,
csOidVendData))
{
RtlFreeUnicodeString (&TempUString);
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in NdisQueryHwAddress = %d", dwRetCode);
dwRetCode = NO_ERROR;
continue;
}
RtlFreeUnicodeString (&TempUString);
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: NdisQueryHwAddress successful");
if (pszGUIDStart != NULL)
{
chGUIDSaveLast = *(pszGUIDEnd);
// Ignore the leading '{' and the trailing '}'
// in the GUID
*(pszGUIDEnd) = (CHAR)NULL;
pszGUIDStart ++;
}
// Verify if a PCB already exists for the interface
// This is possible if no media disconnect was received
// after the initial media connect
ACQUIRE_WRITE_LOCK (&g_PCBLock);
pPCB = ElGetPCBPointerFromPortGUID (pszGUIDStart);
RELEASE_WRITE_LOCK (&g_PCBLock);
// Restore interface buffer
*(pszGUIDEnd) = chGUIDSaveLast;
if (pPCB != NULL)
{
// Point to existing handle
hDevice = pPCB->hPort;
fPCBExists = TRUE;
dwRetCode = NO_ERROR;
TRACE0 (INIT, "ElEnumAndOpenInterfaces: Found PCB already existing for interface");
}
else
{
TRACE0 (INIT, "ElEnumAndOpenInterfaces: Did NOT find PCB already existing for interface");
// Open handle to ndisuio driver
if ((dwRetCode = ElOpenInterfaceHandle (
InterfaceName.Buffer,
&hDevice
)) != NO_ERROR)
{
TRACE1 (INIT, "ElEnumAndOpenInterfaces: ElOpenInterfaceHandle failed with error = %d\n",
dwRetCode );
}
}
*(pszGUIDEnd) = (CHAR)NULL;
}
if (dwRetCode != NO_ERROR)
{
TRACE0 (INIT, "ElEnumAndOpenInterfaces: Failed to open handle");
dwRetCode = NO_ERROR;
continue;
}
else
{
// Verify if EAPOL is to be started on the interface
// at all
if ((dwRetCode = ElGetInterfaceParams (
pszGUIDStart,
&dwEapTypeToBeUsed,
csDummyBuffer,
&dwEapolEnabled
)) != NO_ERROR)
{
TRACE2 (INIT, "ElEnumAndOpenInterfaces: ElGetInterfaceParams failed with error %ld for interface %s",
dwRetCode, pszDesiredGUID);
dwEapTypeToBeUsed = DEFAULT_EAP_TYPE;
dwEapolEnabled = DEFAULT_EAPOL_STATE;
if (dwEapolEnabled)
{
dwRetCode = NO_ERROR;
}
else
{
// Close the handle to the ndisuio driver
if ((dwRetCode = ElCloseInterfaceHandle (hDevice))
!= NO_ERROR)
{
TRACE1 (DEVICE,
"ElEnumAndOpenInterfaces: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
dwRetCode = NO_ERROR;
TRACE1 (INIT, "EAPOL will not be started on %s", InterfaceName.Buffer);
// Continue with other interfaces
continue;
}
}
if (dwEapolEnabled != EAPOL_ENABLED)
{
TRACE1 (INIT, "EAPOL not to be started on interface %s",
pszDesiredGUID);
// Close the handle to the ndisuio driver
if ((dwRetCode = ElCloseInterfaceHandle (hDevice))
!= NO_ERROR)
{
TRACE1 (DEVICE,
"ElEnumAndOpenInterfaces: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
// Continue with the next interface
dwRetCode = NO_ERROR;
continue;
}
// ISSUE:
// What MAC address should we pass to CreatePort
// perm or cur
// Create EAPOL PCB and start state machine
if ((dwRetCode = ElCreatePort (
hDevice,
pszGUIDStart,
InterfaceDescription.Buffer,
csCurrMacAddress
)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in CreatePort = %d", dwRetCode);
// Close the handle to the ndisuio driver
if ((dwRetCode = ElCloseInterfaceHandle (hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE,
"ElEnumAndOpenInterfaces: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
// Continue with the next interface
dwRetCode = NO_ERROR;
continue;
}
else
{
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: CreatePort successful");
// If PCB already existed, do not add to the hash
// table
if (fPCBExists == TRUE)
{
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: PCB already existed, skipping Interface hash table addition");
fPCBExists = FALSE;
dwRetCode = NO_ERROR;
continue;
}
// Add entry to Interface hash table
dwIndex = ElHashInterfaceDescToBucket (
InterfaceDescription.Buffer);
pNewITF = (PEAPOL_ITF)
MALLOC (sizeof (EAPOL_ITF));
if (pNewITF != NULL)
{
pNewITF->pszInterfaceGUID =
(CHAR *) MALLOC (strlen(pszGUIDStart) + 1);
if (pNewITF->pszInterfaceGUID != NULL)
{
memcpy (pNewITF->pszInterfaceGUID,
pszGUIDStart,
strlen (pszGUIDStart));
pNewITF->pszInterfaceGUID[strlen (pszGUIDStart)] = '\0';
}
pNewITF->pszInterfaceDesc =
(CHAR *) MALLOC (strlen(InterfaceDescription.Buffer) + 1);
if (pNewITF->pszInterfaceDesc != NULL)
{
memcpy (pNewITF->pszInterfaceDesc,
InterfaceDescription.Buffer,
strlen (InterfaceDescription.Buffer));
pNewITF->pszInterfaceDesc[strlen (InterfaceDescription.Buffer)] = '\0';
}
pNewITF->pNext =
g_ITFTable.pITFBuckets[dwIndex].pItf;
g_ITFTable.pITFBuckets[dwIndex].pItf = pNewITF;
if ( (pNewITF->pszInterfaceGUID == NULL) ||
(pNewITF->pszInterfaceDesc == NULL))
{
ElRemoveITFFromTable (pNewITF);
if (pNewITF->pszInterfaceDesc)
{
FREE (pNewITF->pszInterfaceDesc);
}
if (pNewITF->pszInterfaceGUID)
{
FREE (pNewITF->pszInterfaceGUID);
}
if (pNewITF)
{
FREE (pNewITF);
}
pNewITF = NULL;
TRACE0 (DEVICE, "ElEnumAndOpenInterfaces: Error in memory allocation, ITF structure not created");
}
}
// Could not create new interface entry
// Delete Port entry created for this GUID
if (pNewITF == NULL)
{
if ((dwRetCode = ElDeletePort (
pszGUIDStart,
&hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElEnumAndOpenInterfaces: Error in deleting port for %s",
pszGUIDStart);
// log
}
// Close the handle to the NDISUIO driver
if ((dwRetCode = ElCloseInterfaceHandle (
hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE,
"ElMediaSenseCallback: Error in ElCloseInterfaceHandle %d",
dwRetCode);
// log
}
}
else
{
TRACE3 (DEVICE, "ElEnumAndOpenInterfaces: Added to hash table GUID= %s : Desc= %s at Index=%d",
pNewITF->pszInterfaceGUID,
pNewITF->pszInterfaceDesc,
dwIndex
);
//
// Interface Handle created successfully
// Notify Zero Config about it
//
}
}
}
} // for (i=0; i < Interfaces
}
else
{
TRACE1(INIT, "ElEnumAndOpenInterfaces: ElNdisuioEnumerateInterfaces failed with error %d",
dwRetCode);
}
TRACE1(INIT, "ElEnumAndOpenInterfaces: Completed with retcode = %d",
dwRetCode);
if (pbNdisuioEnumBuffer != NULL)
{
FREE(pbNdisuioEnumBuffer);
}
return dwRetCode;
}
//
// ElGetCardStatus
//
// Function to query the media information for an interface
//
// Input arguments:
// pDeviceName - Unicode device name
//
// Return values:
// pdwNetCardStatus - Media state
// pdwMediaType - Media type as exposed to NDIS e.g. 802.3
//
DWORD
ElGetCardStatus (
PUNICODE_STRING pDeviceName,
DWORD *pdwNetCardStatus,
DWORD *pdwMediaType
)
{
NIC_STATISTICS Stats;
DWORD dwNicStatus = 0;
DWORD dwRetCode = NO_ERROR;
Stats.Size = sizeof(NIC_STATISTICS);
if (NdisQueryStatistics(pDeviceName, &Stats))
{
switch (Stats.MediaState)
{
case MEDIA_STATE_CONNECTED:
dwNicStatus = MEDIA_STATE_CONNECTED;
TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_CONNECTED\n");
break;
case MEDIA_STATE_DISCONNECTED:
dwNicStatus = MEDIA_STATE_DISCONNECTED;
TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_DISCONNECTED\n");
break;
default:
dwNicStatus = MEDIA_STATE_UNKNOWN;
TRACE0(INIT, "ElGetCardStatus: dwNicStatus = NETCARD_STATUS_UNKNOWN\n");
break;
}
switch (Stats.MediaType)
{
case NdisMedium802_3:
TRACE0 (INIT, "ElGetCardStatus: MediaType is 802.3");
break;
default:
TRACE0 (INIT, "ElGetCardStatus: MediaType is NOT *802.3*");
break;
}
*pdwMediaType = Stats.MediaType;
}
else
{
dwRetCode = GetLastError ();
TRACE1(INIT, "ElGetCardStatus: NdisQueryStatistics failed with error %d\n", dwRetCode);
}
*pdwNetCardStatus = dwNicStatus;
return dwRetCode;
}
//
// ElOpenInterfaceHandle
//
// Description:
//
// Function called to open handle to the NDISUIO driver for an interface.
//
// Arguments:
// DeviceName - Identifier for the interface is of the
// form \Device\{GUID String}
// phDevice - Output pointer to handle of NDISUIO driver for
// the interface
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElOpenInterfaceHandle (
IN CHAR *pszDeviceName,
OUT HANDLE *phDevice
)
{
DWORD dwDesiredAccess;
DWORD dwShareMode;
LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL;
DWORD dwCreationDistribution;
DWORD dwFlagsAndAttributes;
HANDLE hTemplateFile;
HANDLE hHandle;
DWORD dwRetCode = NO_ERROR;
WCHAR wNdisDeviceName[MAX_NDIS_DEVICE_NAME_LEN];
INT wNameLength;
INT NameLength = strlen(pszDeviceName);
DWORD dwBytesReturned;
USHORT wEthernetType=0x8081;
INT i;
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDistribution = OPEN_EXISTING;
dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
hTemplateFile = (HANDLE)INVALID_HANDLE_VALUE;
TRACE1 (INIT, "ElOpenInterfaceHandle: Opening handle for %s", pszDeviceName);
do
{
hHandle = CreateFileA(
pNdisuioDevice,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDistribution,
dwFlagsAndAttributes,
hTemplateFile
);
if (hHandle == INVALID_HANDLE_VALUE)
{
*phDevice = NULL;
dwRetCode = GetLastError();
TRACE1 (INIT, "ElOpenInterfaceHandle: Failed in CreateFile with error %d", dwRetCode);
break;
}
else
{
*phDevice = hHandle;
}
// Convert to unicode string - non-localized...
wNameLength = 0;
for (i = 0; i < NameLength && i < MAX_NDIS_DEVICE_NAME_LEN-1; i++)
{
wNdisDeviceName[i] = (WCHAR)pszDeviceName[i];
wNameLength++;
}
wNdisDeviceName[i] = L'\0';
TRACE1(DEVICE, "ElOpenInterfaceHandle: Trying to access NDIS Device: %ws\n",
wNdisDeviceName);
if (!(DeviceIoControl(
*phDevice,
IOCTL_NDISUIO_OPEN_DEVICE,
(LPVOID)&wNdisDeviceName[0],
wNameLength*sizeof(WCHAR),
NULL,
0,
&dwBytesReturned,
NULL)))
{
*phDevice = NULL;
if ((dwRetCode = GetLastError()) == 0)
{
dwRetCode = ERROR_IO_DEVICE;
}
TRACE1(DEVICE, "ElOpenInterfaceHandle: Error in accessing NDIS Device: %ws", wNdisDeviceName);
break;
}
// IOCTL down the Ethernet type
if (!(DeviceIoControl(
*phDevice,
IOCTL_NDISUIO_SET_ETHER_TYPE,
(LPVOID)&wEthernetType,
sizeof(USHORT),
NULL,
0,
&dwBytesReturned,
NULL)))
{
*phDevice = NULL;
if ((dwRetCode = GetLastError()) == 0)
{
dwRetCode = ERROR_IO_DEVICE;
}
TRACE1(DEVICE, "ElOpenInterfaceHandle: Error in ioctling ETHER type : %ws", wNdisDeviceName);
break;
}
// Bind for asynchronous I/O handling of Read/Write data
// Depending on whether it is completion for Readfile() or WriteFile()
// ElIoCompletionRoutine will call ElReadCompletionRoutine
// or ElWriteCompletionRoutine
if (!BindIoCompletionCallback(
*phDevice,
ElIoCompletionRoutine,
0
))
{
*phDevice = NULL;
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElOpenInterfaceHandle: Error in BindIoCompletionCallBac %d", dwRetCode);
break;
}
} while (FALSE);
// Cleanup if there is error
if (dwRetCode != NO_ERROR)
{
if (hHandle != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(hHandle))
{
dwRetCode = GetLastError();
TRACE1 (INIT, "ElOpenInterfaceHandle: Error in CloseHandle %d", dwRetCode);
}
}
}
TRACE2 (INIT, "ElOpenInterfaceHandle: Opened handle %p with dwRetCode %d", *phDevice, dwRetCode);
return (dwRetCode);
}
//
// ElCloseInterfaceHandle
//
// Description:
//
// Function called to close handle to NDISUIO driver for an interface
//
// Arguments:
// hDevice - Handle to NDISUIO device for the interface
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElCloseInterfaceHandle (
IN HANDLE hDevice
)
{
DWORD dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElCloseInterfaceHandle entered");
if (!CloseHandle(hDevice))
{
dwRetCode = GetLastError();
TRACE1 (INIT, "ElCloseInterfaceHandle: Error in CloseHandle %d",
dwRetCode);
}
return dwRetCode;
}
//
// ElReadFromInterface
//
// Description:
//
// Function called to perform Overlapped read on handle to NDISUIO driver
//
// Arguments:
// hDevice - Handle to NDISUIO driver for this interface
// pElBuffer - Context buffer
// dwBufferLength - Bytes to be read
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElReadFromInterface (
IN HANDLE hDevice,
IN PEAPOL_BUFFER pElBuffer,
IN DWORD dwBufferLength
)
{
DWORD dwRetCode = NO_ERROR;
if (!ReadFile (
hDevice,
pElBuffer->pBuffer,
dwBufferLength,
NULL,
&pElBuffer->Overlapped
))
{
dwRetCode = GetLastError();
if (dwRetCode == ERROR_IO_PENDING)
{
// Pending status is fine, we are doing OVERLAPPED read
dwRetCode = NO_ERROR;
}
else
{
TRACE1 (DEVICE, "ElReadFromInterface: ReadFile failed with error %d",
dwRetCode);
}
}
return dwRetCode;
}
//
// ElWriteToInterface
//
// Description:
//
// Function called to perform Overlapped write on handle to NDISUIO driver
//
// Arguments:
// hDevice - Handle to NDISUIO device for this interface
// pElBuffer - Context buffer
// dwBufferLength - Bytes to be written
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElWriteToInterface (
IN HANDLE hDevice,
IN PEAPOL_BUFFER pElBuffer,
IN DWORD dwBufferLength
)
{
DWORD dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElWriteToInterface entered");
if (!WriteFile (
hDevice,
pElBuffer->pBuffer,
dwBufferLength,
NULL,
&pElBuffer->Overlapped
))
{
dwRetCode = GetLastError();
if (dwRetCode == ERROR_IO_PENDING)
{
// Pending status is fine, we are doing OVERLAPPED write
dwRetCode = NO_ERROR;
}
else
{
TRACE1 (DEVICE, "ElWriteToInterface: WriteFile failed with error %d",
dwRetCode);
}
}
TRACE1 (DEVICE, "ElWriteToInterface completed, dwRetCode = %d", dwRetCode);
return dwRetCode;
}
//
// ElHashInterfaceDescToBucket
//
// Description:
//
// Function called to convert Friendly name of interface into interface hash
// table index.
//
// Arguments:
// pszInterfaceDesc - Friendly name of the interface
//
// Return values:
// Hash table index between from 0 to INTF_TABLE_BUCKETS-1
//
DWORD
ElHashInterfaceDescToBucket (
IN CHAR *pszInterfaceDesc
)
{
return ((DWORD)((atol(pszInterfaceDesc)) % INTF_TABLE_BUCKETS));
}
//
// ElGetITFPointerFromInterfaceDesc
//
// Description:
//
// Function called to convert Friendly name of interface to ITF entry pointer
//
// Arguments:
// pszInterfaceDesc - Friendly name of the interface
//
// Return values:
// Pointer to interface entry in hash table
//
PEAPOL_ITF
ElGetITFPointerFromInterfaceDesc (
IN CHAR *pszInterfaceDesc
)
{
EAPOL_ITF *pITFWalker = NULL;
DWORD dwIndex;
INT i=0;
TRACE1 (DEVICE, "ElGetITFPointerFromInterfaceDesc: Desc = %s", pszInterfaceDesc);
if (pszInterfaceDesc == NULL)
{
return (NULL);
}
dwIndex = ElHashInterfaceDescToBucket (pszInterfaceDesc);
TRACE1 (DEVICE, "ElGetITFPointerFromItfDesc: Index %d", dwIndex);
for (pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
pITFWalker != NULL;
pITFWalker = pITFWalker->pNext
)
{
if (strncmp (pITFWalker->pszInterfaceDesc, pszInterfaceDesc, strlen(pszInterfaceDesc)) == 0)
{
return pITFWalker;
}
}
return (NULL);
}
//
// ElRemoveITFFromTable
//
// Description:
//
// Function called to remove an interface entry from the interface hash
// table
//
// Arguments:
// pITF - Point to the Interface entry in the hash table
//
// Return values:
//
VOID
ElRemoveITFFromTable (
IN EAPOL_ITF *pITF
)
{
DWORD dwIndex;
EAPOL_ITF *pITFWalker = NULL;
EAPOL_ITF *pITFTemp = NULL;
if (pITF == NULL)
{
TRACE0 (EAPOL, "ElRemoveITFFromTable: Deleting NULL ITF, returning");
return;
}
dwIndex = ElHashInterfaceDescToBucket (pITF->pszInterfaceDesc);
pITFWalker = g_ITFTable.pITFBuckets[dwIndex].pItf;
pITFTemp = pITFWalker;
while (pITFTemp != NULL)
{
if (strncmp (pITFTemp->pszInterfaceGUID,
pITF->pszInterfaceGUID, strlen(pITF->pszInterfaceGUID)) == 0)
{
// Entry is at head of list in table
if (pITFTemp == g_ITFTable.pITFBuckets[dwIndex].pItf)
{
g_ITFTable.pITFBuckets[dwIndex].pItf = pITFTemp->pNext;
}
else
{
// Entry is inside list in table
pITFWalker->pNext = pITFTemp->pNext;
}
break;
}
pITFWalker = pITFTemp;
pITFTemp = pITFWalker->pNext;
}
return;
}
//
// ElNdisuioEnumerateInterfaces
//
// Description:
//
// Function called to enumerate the interfaces on which NDISUIO is bound
//
// Arguments:
// pBuffer - Pointer to buffer which will hold interface details
// dwAvailableInterfaces - Number of interfaces for which details can
// be held in pItfBuffer
// dwBufferSize - Number of bytes in pItfBuffer
//
// Return values:
//
DWORD
ElNdisuioEnumerateInterfaces (
IN OUT PNDIS_ENUM_INTF pItfBuffer,
IN DWORD dwAvailableInterfaces,
IN DWORD dwBufferSize
)
{
DWORD dwDesiredAccess;
DWORD dwShareMode;
LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL;
DWORD dwCreationDistribution;
DWORD dwFlagsAndAttributes;
HANDLE hTemplateFile;
HANDLE hHandle;
DWORD dwBytesReturned = 0;
INT i;
CHAR Buf[1024];
DWORD BufLength = sizeof(Buf);
DWORD BytesWritten = 0;
PNDISUIO_QUERY_BINDING pQueryBinding = NULL;
PCHAR pTempBuf = NULL;
DWORD dwRetCode = NO_ERROR;
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDistribution = OPEN_EXISTING;
dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
hTemplateFile = (HANDLE)INVALID_HANDLE_VALUE;
TRACE0 (DEVICE, "ElNdisuioEnumerateInterfaces: Opening handle");
do
{
hHandle = CreateFileA (
pNdisuioDevice,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDistribution,
0,
NULL
);
if (hHandle == INVALID_HANDLE_VALUE)
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Failed in CreateFile with error %d", dwRetCode);
break;
}
// Send IOCTL to ensure NDISUIO binds to all relevant interfaces
if (!DeviceIoControl (
hHandle,
IOCTL_NDISUIO_BIND_WAIT,
NULL,
0,
NULL,
0,
&dwBytesReturned,
NULL))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Failed in DeviceIoCoontrol NDISUIO_BIND_WAIT with error %d", dwRetCode);
break;
}
pQueryBinding = (PNDISUIO_QUERY_BINDING)Buf;
pTempBuf = (PBYTE)pItfBuffer + dwBufferSize;
i = 0;
for (pQueryBinding->BindingIndex = i;
pQueryBinding->BindingIndex < dwAvailableInterfaces;
pQueryBinding->BindingIndex = ++i)
{
Try_Again:
g_QueryBinding = NULL;
g_TempBuf = NULL;
g_ItfBuffer = NULL;
g_Buf = NULL;
g_ItfBufferSize = 0;
g_BreakAt = 1;
// Query for one interface at a time
if (DeviceIoControl (
hHandle,
IOCTL_NDISUIO_QUERY_BINDING,
pQueryBinding,
sizeof(NDISUIO_QUERY_BINDING),
Buf,
BufLength,
&BytesWritten,
NULL))
{
TRACE3 (DEVICE, "NdisuioEnumerateInterfaces: NDISUIO bound to: %2d. %ws\n - %ws\n",
pQueryBinding->BindingIndex,
(PUCHAR)pQueryBinding + pQueryBinding->DeviceNameOffset,
(PUCHAR)pQueryBinding + pQueryBinding->DeviceDescrOffset);
g_QueryBinding = (PVOID)pQueryBinding;
g_TempBuf = (PVOID)pTempBuf;
g_ItfBuffer = (PVOID)pItfBuffer;
g_ItfBufferSize = dwBufferSize;
g_Buf = (PVOID)Buf;
g_BreakAt = 1;
pTempBuf = pTempBuf - ((pQueryBinding->DeviceNameLength + 7) & 0xfffffff8);
if (((PBYTE)pTempBuf - (PBYTE)&pItfBuffer->Interface[pItfBuffer->TotalInterfaces]) <= 0)
{
// Going beyond start of buffer, Error
TRACE0 (DEVICE, "NdisuioEnumerateInterfaces: DeviceName: Memory being corrupted !!!");
DebugBreak ();
goto Try_Again;
}
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Buffer = (PWCHAR) pTempBuf;
memcpy ((BYTE *)(pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Buffer), (BYTE *)((PUCHAR)pQueryBinding + pQueryBinding->DeviceNameOffset), (pQueryBinding->DeviceNameLength - sizeof(WCHAR)));
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.Length = (SHORT) ( pQueryBinding->DeviceNameLength - sizeof(WCHAR));
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceName.MaximumLength = (SHORT) ( pQueryBinding->DeviceNameLength - sizeof(WCHAR));
pTempBuf = pTempBuf - ((pQueryBinding->DeviceDescrLength + 7) & 0xfffffff8);;
g_BreakAt = 2;
if (((PBYTE)pTempBuf - (PBYTE)&pItfBuffer->Interface[pItfBuffer->TotalInterfaces]) <= 0)
{
// Going beyond start of buffer, Error
TRACE0 (DEVICE, "NdisuioEnumerateInterfaces: DeviceDescr: Memory being corrupted !!!");
DebugBreak ();
goto Try_Again;
}
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Buffer = (PWCHAR) pTempBuf;
memcpy ((pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Buffer), (PWCHAR)((PUCHAR)pQueryBinding + pQueryBinding->DeviceDescrOffset), (pQueryBinding->DeviceDescrLength - sizeof(WCHAR)));
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.Length = (SHORT) (pQueryBinding->DeviceDescrLength - sizeof(WCHAR));
pItfBuffer->Interface[pItfBuffer->TotalInterfaces].DeviceDescription.MaximumLength = (SHORT) (pQueryBinding->DeviceDescrLength - sizeof(WCHAR));
pItfBuffer->TotalInterfaces++;
memset(Buf, 0, BufLength);
}
else
{
dwRetCode = GetLastError ();
if (dwRetCode != ERROR_NO_MORE_ITEMS)
{
TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: DeviceIoControl terminated for with IOCTL_NDISUIO_QUERY_BINDING with error %ld",
dwRetCode);
}
else
{
// Reset error, since it only indicates end-of-list
dwRetCode = NO_ERROR;
TRACE0 (DEVICE, "ElNdisuioEnumerateInterfaces: DeviceIoControl IOCTL_NDISUIO_QUERY_BINDING has no more entries");
}
break;
}
}
} while (FALSE);
// Cleanup
if (hHandle != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(hHandle))
{
dwRetCode = GetLastError();
TRACE1 (DEVICE, "ElNdisuioEnumerateInterfaces: Error in CloseHandle %d", dwRetCode);
}
}
TRACE2 (DEVICE, "ElNdisuioEnumerateInterfaces: Opened handle %p with dwRetCode %d",
hHandle, dwRetCode);
return dwRetCode;
}
//
// ElShutdownInterface
//
// Description:
//
// Function called to stop EAPOL state machine, close handle to NDISUIO and
// remove existence of the interface from the module
//
// Arguments:
// pszGUID - Pointer to interface GUID
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElShutdownInterface (
IN CHAR *pszGUID
)
{
EAPOL_PCB *pPCB = NULL;
EAPOL_ITF *pITF = NULL;
HANDLE hDevice = NULL;
DWORD dwRetCode = NO_ERROR;
do
{
TRACE0(DEVICE, "ElShutdownInterface: Called for interface removal");
ACQUIRE_WRITE_LOCK (&(g_ITFLock));
// Check if EAPOL was actually started on this interface
// Verify by checking existence of corresponding
// entry in hash table
ACQUIRE_WRITE_LOCK (&(g_PCBLock));
if ((pPCB = ElGetPCBPointerFromPortGUID(pszGUID))
!= NULL)
{
RELEASE_WRITE_LOCK (&(g_PCBLock));
TRACE0 (DEVICE, "ElShutdownInterface: Found PCB entry for interface");
if ((pITF = ElGetITFPointerFromInterfaceDesc(
pPCB->pszFriendlyName))
== NULL)
{
TRACE0 (DEVICE, "ElShutdownInterface: Did not find ITF entry when PCB exits, HOW BIZARRE !!!");
}
if ((dwRetCode = ElDeletePort (
pszGUID,
&hDevice)) != NO_ERROR)
{
TRACE1 (DEVICE, "ElShutdownInterface: Error in deleting port for %s",
pPCB->pszDeviceGUID);
}
// Remove interface entry from interface table
if (pITF != NULL)
{
ElRemoveITFFromTable(pITF);
if (pITF->pszInterfaceDesc)
{
FREE (pITF->pszInterfaceDesc);
}
if (pITF->pszInterfaceGUID)
{
FREE (pITF->pszInterfaceGUID);
}
if (pITF)
{
FREE (pITF);
}
}
// Close the handle to the NDISUIO driver
if (hDevice != NULL)
{
if ((dwRetCode = ElCloseInterfaceHandle (hDevice))
!= NO_ERROR)
{
TRACE1 (DEVICE,
"ElShutdownInterface: Error in ElCloseInterfaceHandle %d",
dwRetCode);
}
}
TRACE1 (DEVICE, "ElShutdownInterface: Port deleted %s",
pszGUID);
}
else
{
RELEASE_WRITE_LOCK (&(g_PCBLock));
// Ignore device removal
TRACE0 (DEVICE, "ElShutdownInterface: ElGetPCBPointerFromPortGUID did not find any matching entry, ignoring interface REMOVAL");
}
RELEASE_WRITE_LOCK (&g_ITFLock);
} while (FALSE);
return dwRetCode;
}
Reference in a new issue Copy permalink