You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
809 lines
22 KiB
809 lines
22 KiB
/********************************************************************/
|
|
/** Copyright(c) 1995 Microsoft Corporation. **/
|
|
/********************************************************************/
|
|
|
|
//***
|
|
//
|
|
// Filename: ifobject.c
|
|
//
|
|
// Description: Routines to manipulate ROUTER_INTERFACE_OBJECTs
|
|
//
|
|
// History: May 11,1995 NarenG Created original version.
|
|
//
|
|
|
|
#include "dimsvcp.h"
|
|
#include <netconp.h>
|
|
|
|
//**
|
|
//
|
|
// Call: GetNewIfHandle
|
|
//
|
|
// Returns: Handle for new interface
|
|
//
|
|
// Description: Will generate an id that will be used for an handle to the new
|
|
// interface.
|
|
//
|
|
HANDLE
|
|
GetNewIfHandle(
|
|
VOID
|
|
)
|
|
{
|
|
static DWORD Id = 2;
|
|
|
|
return( (HANDLE)UlongToPtr(Id++) );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectAllocateAndInit
|
|
//
|
|
// Returns: ROUTER_INTERFACE_OBJECT * - Success
|
|
// NULL - Failure
|
|
//
|
|
// Description: Allocates and initializes a ROUTER_INTERFACE_OBJECT structure
|
|
//
|
|
ROUTER_INTERFACE_OBJECT *
|
|
IfObjectAllocateAndInit(
|
|
IN LPWSTR lpwstrName,
|
|
IN ROUTER_INTERFACE_STATE State,
|
|
IN ROUTER_INTERFACE_TYPE IfType,
|
|
IN HCONN hConnection,
|
|
IN BOOL fEnabled,
|
|
IN DWORD dwInterfaceReachableAfterSecondsMin,
|
|
IN DWORD dwInterfaceReachableAfterSecondsMax,
|
|
IN LPWSTR lpwsDialoutHoursRestriction,
|
|
IN PVOID * ppvContext
|
|
)
|
|
{
|
|
DWORD dwRetCode;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
DWORD dwIfObjectSize;
|
|
DWORD dwTransportIndex;
|
|
|
|
|
|
//
|
|
// On a workstation we do not allow creation of demand-dial interfaces
|
|
//
|
|
|
|
if ( gblDIMConfigInfo.NtProductType == NtProductWinNt )
|
|
{
|
|
if ( ( IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
|
|
{
|
|
WCHAR * pChar = lpwstrName;
|
|
|
|
DIMLogWarning( ROUTERLOG_LIMITED_WKSTA_SUPPORT,1, &pChar );
|
|
|
|
SetLastError( ERROR_NOT_SUPPORTED );
|
|
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Hardcode to 2 routermanagers, one for IP, one for IPX. We need to do this
|
|
// because then we do not need to reallocate the size to accomodate a new protocol
|
|
// when it is added dynamically to the router
|
|
//
|
|
|
|
dwIfObjectSize = sizeof( ROUTER_INTERFACE_OBJECT )
|
|
+ ( sizeof( ROUTER_INTERFACE_TRANSPORT ) * 2 );
|
|
|
|
pIfObject = (ROUTER_INTERFACE_OBJECT *)LOCAL_ALLOC( LPTR, dwIfObjectSize );
|
|
|
|
if ( pIfObject == (ROUTER_INTERFACE_OBJECT *)NULL )
|
|
{
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
|
|
pIfObject->lpwsInterfaceName = (LPWSTR)LOCAL_ALLOC( LPTR,
|
|
(wcslen(lpwstrName)+1)
|
|
* sizeof(WCHAR) );
|
|
|
|
if ( pIfObject->lpwsInterfaceName == (LPWSTR)NULL )
|
|
{
|
|
IfObjectFree( pIfObject );
|
|
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
|
|
if ( ( IfType == ROUTER_IF_TYPE_DEDICATED ) ||
|
|
( IfType == ROUTER_IF_TYPE_TUNNEL1 ) ||
|
|
( IfType == ROUTER_IF_TYPE_INTERNAL ) )
|
|
{
|
|
if ( !fEnabled )
|
|
{
|
|
WCHAR * pChar = lpwstrName;
|
|
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
|
|
DIMLogErrorString( ROUTERLOG_COULDNT_LOAD_IF, 1, &pChar,
|
|
ERROR_INVALID_PARAMETER, 1 );
|
|
|
|
IfObjectFree( pIfObject );
|
|
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
}
|
|
|
|
pIfObject->dwReachableAfterSecondsMin=dwInterfaceReachableAfterSecondsMin;
|
|
pIfObject->dwReachableAfterSecondsMax=dwInterfaceReachableAfterSecondsMax;
|
|
pIfObject->dwReachableAfterSeconds =dwInterfaceReachableAfterSecondsMin;
|
|
|
|
wcscpy( pIfObject->lpwsInterfaceName, lpwstrName );
|
|
|
|
pIfObject->State = State;
|
|
pIfObject->IfType = IfType;
|
|
pIfObject->hConnection = hConnection;
|
|
pIfObject->hDIMInterface = ( IfType == ROUTER_IF_TYPE_LOOPBACK )
|
|
? (HANDLE)1
|
|
: GetNewIfHandle();
|
|
pIfObject->fFlags = ( fEnabled ) ? IFFLAG_ENABLED : 0;
|
|
pIfObject->hEventNotifyCaller = INVALID_HANDLE_VALUE;
|
|
|
|
//
|
|
// Initialize the router manager handles
|
|
//
|
|
|
|
for ( dwTransportIndex = 0;
|
|
dwTransportIndex < gblDIMConfigInfo.dwNumRouterManagers;
|
|
dwTransportIndex++ )
|
|
{
|
|
pIfObject->Transport[dwTransportIndex].hInterface=INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
//
|
|
// If we are running in LANONLYMode then we do not care about media bits
|
|
//
|
|
|
|
if ( gblDIMConfigInfo.dwRouterRole == ROUTER_ROLE_LAN )
|
|
{
|
|
return( pIfObject );
|
|
}
|
|
|
|
if ( ( IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
|
|
{
|
|
DWORD
|
|
(*IfObjectLoadPhonebookInfo)( ROUTER_INTERFACE_OBJECT *, VOID * ) =
|
|
(DWORD(*)( ROUTER_INTERFACE_OBJECT *, VOID * ))
|
|
GetDDMEntryPoint("IfObjectLoadPhonebookInfo");
|
|
|
|
if(NULL == IfObjectLoadPhonebookInfo)
|
|
{
|
|
SetLastError( ERROR_PROC_NOT_FOUND );
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Load phonebook information for this interface
|
|
//
|
|
|
|
dwRetCode = IfObjectLoadPhonebookInfo( pIfObject, ppvContext );
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
if ( dwRetCode == ERROR_INTERFACE_HAS_NO_DEVICES )
|
|
{
|
|
pIfObject->fFlags |= IFFLAG_OUT_OF_RESOURCES;
|
|
}
|
|
else
|
|
{
|
|
WCHAR * pChar = lpwstrName;
|
|
|
|
DIMLogErrorString( ROUTERLOG_COULDNT_LOAD_IF, 1, &pChar,
|
|
dwRetCode, 1 );
|
|
|
|
SetLastError( dwRetCode );
|
|
|
|
IfObjectFree( pIfObject );
|
|
|
|
return( NULL );
|
|
}
|
|
}
|
|
|
|
pIfObject->lpwsDialoutHoursRestriction = lpwsDialoutHoursRestriction;
|
|
}
|
|
|
|
return( pIfObject );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectInsertInTable
|
|
//
|
|
// Returns: NO_ERROR - Success
|
|
// ERROR_MAX_WAN_INTERFACE_LIMIT - Failure
|
|
// ERROR_MAX_LAN_INTERFACE_LIMIT - Failure
|
|
// ERROR_MAX_CLIENT_INTERFACE_LIMIT - Failure
|
|
//
|
|
// Description: Will insert this interface object into the interface object
|
|
// table
|
|
//
|
|
DWORD
|
|
IfObjectInsertInTable(
|
|
IN ROUTER_INTERFACE_OBJECT * pIfObject
|
|
)
|
|
{
|
|
DWORD dwBucketIndex=IfObjectHashIfHandleToBucket(pIfObject->hDIMInterface);
|
|
|
|
if ( pIfObject->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
|
|
{
|
|
if ( gblInterfaceTable.dwNumWanInterfaces == DIM_MAX_WAN_INTERFACES )
|
|
{
|
|
return( ERROR_MAX_WAN_INTERFACE_LIMIT );
|
|
}
|
|
else
|
|
{
|
|
gblInterfaceTable.dwNumWanInterfaces++;
|
|
}
|
|
}
|
|
else if ( pIfObject->IfType == ROUTER_IF_TYPE_DEDICATED )
|
|
{
|
|
if ( gblInterfaceTable.dwNumLanInterfaces == DIM_MAX_LAN_INTERFACES )
|
|
{
|
|
return( ERROR_MAX_LAN_INTERFACE_LIMIT );
|
|
}
|
|
else
|
|
{
|
|
gblInterfaceTable.dwNumLanInterfaces++;
|
|
}
|
|
}
|
|
else if ( pIfObject->IfType == ROUTER_IF_TYPE_CLIENT )
|
|
{
|
|
if (gblInterfaceTable.dwNumClientInterfaces==DIM_MAX_CLIENT_INTERFACES)
|
|
{
|
|
return( ERROR_MAX_CLIENT_INTERFACE_LIMIT );
|
|
}
|
|
else
|
|
{
|
|
gblInterfaceTable.dwNumClientInterfaces++;
|
|
}
|
|
}
|
|
|
|
pIfObject->pNext = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
|
|
gblInterfaceTable.IfBucket[dwBucketIndex] = pIfObject;
|
|
|
|
gblInterfaceTable.dwNumTotalInterfaces++;
|
|
|
|
return( NO_ERROR );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Description:
|
|
//
|
|
ROUTER_INTERFACE_OBJECT *
|
|
IfObjectGetPointer(
|
|
IN HANDLE hDIMInterface
|
|
)
|
|
{
|
|
DWORD dwBucketIndex;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
|
|
dwBucketIndex = IfObjectHashIfHandleToBucket(hDIMInterface);
|
|
|
|
for( pIfObject = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
pIfObject != (ROUTER_INTERFACE_OBJECT *)NULL;
|
|
pIfObject = pIfObject->pNext )
|
|
{
|
|
if ( pIfObject->hDIMInterface == hDIMInterface )
|
|
{
|
|
return( pIfObject );
|
|
}
|
|
}
|
|
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectHashIfHandleToBucket
|
|
//
|
|
// Returns:
|
|
//
|
|
// Description:
|
|
//
|
|
DWORD
|
|
IfObjectHashIfHandleToBucket(
|
|
IN HANDLE hDIMInterface
|
|
)
|
|
{
|
|
return( (DWORD)((ULONG_PTR)hDIMInterface) % NUM_IF_BUCKETS );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectRemove
|
|
//
|
|
// Returns:
|
|
//
|
|
// Description:
|
|
//
|
|
VOID
|
|
IfObjectRemove(
|
|
IN HANDLE hDIMInterface
|
|
)
|
|
{
|
|
DWORD dwBucketIndex;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
ROUTER_INTERFACE_OBJECT * pIfObjectPrev;
|
|
|
|
dwBucketIndex = IfObjectHashIfHandleToBucket(hDIMInterface);
|
|
|
|
pIfObject = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
pIfObjectPrev = pIfObject;
|
|
|
|
while( pIfObject != (ROUTER_INTERFACE_OBJECT *)NULL )
|
|
{
|
|
if ( pIfObject->hDIMInterface == hDIMInterface )
|
|
{
|
|
if ( gblInterfaceTable.IfBucket[dwBucketIndex] == pIfObject )
|
|
{
|
|
gblInterfaceTable.IfBucket[dwBucketIndex] = pIfObject->pNext;
|
|
}
|
|
else
|
|
{
|
|
pIfObjectPrev->pNext = pIfObject->pNext;
|
|
}
|
|
|
|
gblInterfaceTable.dwNumTotalInterfaces--;
|
|
|
|
if ( pIfObject->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
|
|
{
|
|
gblInterfaceTable.dwNumWanInterfaces--;
|
|
}
|
|
else if ( pIfObject->IfType == ROUTER_IF_TYPE_DEDICATED )
|
|
{
|
|
gblInterfaceTable.dwNumLanInterfaces--;
|
|
}
|
|
else if ( pIfObject->IfType == ROUTER_IF_TYPE_CLIENT )
|
|
{
|
|
gblInterfaceTable.dwNumClientInterfaces--;
|
|
}
|
|
|
|
IfObjectFree( pIfObject );
|
|
|
|
return;
|
|
}
|
|
|
|
pIfObjectPrev = pIfObject;
|
|
pIfObject = pIfObject->pNext;
|
|
}
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectFree
|
|
//
|
|
// Returns: NO_ERROR - Success
|
|
// Non-zero returns - Failure
|
|
//
|
|
// Description: Will release all memory allocated for the interfae object.
|
|
//
|
|
VOID
|
|
IfObjectFree(
|
|
IN ROUTER_INTERFACE_OBJECT * pIfObject
|
|
)
|
|
{
|
|
if ( pIfObject->lpwsInterfaceName != NULL )
|
|
{
|
|
LOCAL_FREE( pIfObject->lpwsInterfaceName );
|
|
}
|
|
|
|
if ( pIfObject->lpwsDialoutHoursRestriction != NULL )
|
|
{
|
|
LOCAL_FREE( pIfObject->lpwsDialoutHoursRestriction );
|
|
}
|
|
|
|
LOCAL_FREE( pIfObject );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectGetPointerByName
|
|
//
|
|
// Returns:
|
|
//
|
|
// Description:
|
|
//
|
|
ROUTER_INTERFACE_OBJECT *
|
|
IfObjectGetPointerByName(
|
|
IN LPWSTR lpwstrName,
|
|
IN BOOL fIncludeClientInterfaces
|
|
)
|
|
{
|
|
DWORD dwBucketIndex;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
|
|
for ( dwBucketIndex = 0; dwBucketIndex < NUM_IF_BUCKETS; dwBucketIndex++ )
|
|
{
|
|
for( pIfObject = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
pIfObject != (ROUTER_INTERFACE_OBJECT *)NULL;
|
|
pIfObject = pIfObject->pNext )
|
|
{
|
|
if ( _wcsicmp( pIfObject->lpwsInterfaceName, lpwstrName ) == 0 )
|
|
{
|
|
if ( pIfObject->IfType == ROUTER_IF_TYPE_CLIENT )
|
|
{
|
|
if ( fIncludeClientInterfaces )
|
|
{
|
|
return( pIfObject );
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return( pIfObject );
|
|
}
|
|
}
|
|
}
|
|
|
|
return( (ROUTER_INTERFACE_OBJECT *)NULL );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectDoesLanInterfaceExist
|
|
//
|
|
// Returns: NO_ERROR - Success
|
|
// Non-zero returns - Failure
|
|
//
|
|
// Description:
|
|
//
|
|
BOOL
|
|
IfObjectDoesLanInterfaceExist(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD dwBucketIndex;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
|
|
for ( dwBucketIndex = 0; dwBucketIndex < NUM_IF_BUCKETS; dwBucketIndex++ )
|
|
{
|
|
for( pIfObject = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
pIfObject != (ROUTER_INTERFACE_OBJECT *)NULL;
|
|
pIfObject = pIfObject->pNext )
|
|
{
|
|
if ( pIfObject->IfType == ROUTER_IF_TYPE_DEDICATED )
|
|
{
|
|
return( TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
return( FALSE );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectWANDeviceInstalled
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Description: Called by DDM whenever a WAN device is installed or removed
|
|
//
|
|
VOID
|
|
IfObjectWANDeviceInstalled(
|
|
IN BOOL fWANDeviceInstalled
|
|
)
|
|
{
|
|
DWORD dwXportIndex = GetTransportIndex( PID_IP );
|
|
|
|
//
|
|
// If a WAN device is installed and IP is installed then we
|
|
// start advertizing on specific multicast address so as to make this
|
|
// router discoverable
|
|
//
|
|
|
|
if ( ( fWANDeviceInstalled ) && ( dwXportIndex != (DWORD)-1 ) )
|
|
{
|
|
DWORD dwRetCode =
|
|
gblRouterManagers[dwXportIndex].DdmRouterIf.SetRasAdvEnable(
|
|
fWANDeviceInstalled );
|
|
|
|
DIMTRACE2( "Calling SetRasAdvEnable( %d ) = %d",
|
|
fWANDeviceInstalled, dwRetCode );
|
|
}
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectNotifyOfMediaSenseChange
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Description: Notifies the object of change in reachablity status due to
|
|
// media sense.
|
|
//
|
|
//
|
|
VOID
|
|
IfObjectNotifyOfMediaSenseChange(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD dwBucketIndex;
|
|
ROUTER_INTERFACE_OBJECT * pIfObject;
|
|
|
|
EnterCriticalSection( &(gblInterfaceTable.CriticalSection) );
|
|
|
|
for ( dwBucketIndex = 0; dwBucketIndex < NUM_IF_BUCKETS; dwBucketIndex++ )
|
|
{
|
|
for( pIfObject = gblInterfaceTable.IfBucket[dwBucketIndex];
|
|
pIfObject != (ROUTER_INTERFACE_OBJECT *)NULL;
|
|
pIfObject = pIfObject->pNext )
|
|
{
|
|
if ( pIfObject->IfType == ROUTER_IF_TYPE_DEDICATED )
|
|
{
|
|
DWORD dwInactiveReason;
|
|
|
|
if ( IfObjectIsLANDeviceActive( pIfObject->lpwsInterfaceName,
|
|
&dwInactiveReason ) )
|
|
{
|
|
if ( pIfObject->State != RISTATE_CONNECTED )
|
|
{
|
|
pIfObject->State = RISTATE_CONNECTED;
|
|
|
|
pIfObject->fFlags &= ~IFFLAG_NO_MEDIA_SENSE;
|
|
|
|
IfObjectNotifyOfReachabilityChange(
|
|
pIfObject,
|
|
TRUE,
|
|
INTERFACE_NO_MEDIA_SENSE );
|
|
}
|
|
}
|
|
else if ( dwInactiveReason == INTERFACE_NO_MEDIA_SENSE )
|
|
{
|
|
if ( pIfObject->State != RISTATE_DISCONNECTED )
|
|
{
|
|
pIfObject->State = RISTATE_DISCONNECTED;
|
|
|
|
pIfObject->fFlags |= IFFLAG_NO_MEDIA_SENSE;
|
|
|
|
IfObjectNotifyOfReachabilityChange(
|
|
pIfObject,
|
|
FALSE,
|
|
INTERFACE_NO_MEDIA_SENSE );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection( &(gblInterfaceTable.CriticalSection) );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectNotifyOfReachabilityChange
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Description: Notifies the object of change in reachablity status due to
|
|
// media sense.
|
|
//
|
|
//
|
|
VOID
|
|
IfObjectNotifyOfReachabilityChange(
|
|
IN ROUTER_INTERFACE_OBJECT * pIfObject,
|
|
IN BOOL fReachable,
|
|
IN UNREACHABILITY_REASON dwReason
|
|
)
|
|
{
|
|
DWORD dwIndex;
|
|
WCHAR wchFriendlyName[MAX_INTERFACE_NAME_LEN+1];
|
|
LPWSTR lpszFriendlyName = wchFriendlyName;
|
|
|
|
for ( dwIndex = 0;
|
|
dwIndex < gblDIMConfigInfo.dwNumRouterManagers;
|
|
dwIndex++ )
|
|
{
|
|
if ( pIfObject->Transport[dwIndex].hInterface == INVALID_HANDLE_VALUE )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( fReachable )
|
|
{
|
|
DIMTRACE2( "Notifying Protocol = 0x%x, Interface=%ws is Reachable",
|
|
gblRouterManagers[dwIndex].DdmRouterIf.dwProtocolId,
|
|
pIfObject->lpwsInterfaceName );
|
|
|
|
gblRouterManagers[dwIndex].DdmRouterIf.InterfaceReachable(
|
|
pIfObject->Transport[dwIndex].hInterface );
|
|
}
|
|
else
|
|
{
|
|
DIMTRACE3(
|
|
"Notifying Protocol = 0x%x,Interface=%ws is UnReachable=%d",
|
|
gblRouterManagers[dwIndex].DdmRouterIf.dwProtocolId,
|
|
pIfObject->lpwsInterfaceName,
|
|
dwReason );
|
|
|
|
gblRouterManagers[dwIndex].DdmRouterIf.InterfaceNotReachable(
|
|
pIfObject->Transport[dwIndex].hInterface,
|
|
dwReason );
|
|
}
|
|
}
|
|
|
|
if ( MprConfigGetFriendlyName( gblDIMConfigInfo.hMprConfig,
|
|
pIfObject->lpwsInterfaceName,
|
|
wchFriendlyName,
|
|
sizeof( wchFriendlyName ) ) != NO_ERROR )
|
|
{
|
|
wcscpy( wchFriendlyName, pIfObject->lpwsInterfaceName );
|
|
}
|
|
|
|
if ( fReachable )
|
|
{
|
|
DIMLogInformation(ROUTERLOG_IF_REACHABLE,1, &lpszFriendlyName );
|
|
}
|
|
else
|
|
{
|
|
DWORD dwEventLogId = 0;
|
|
|
|
switch( dwReason )
|
|
{
|
|
case INTERFACE_OUT_OF_RESOURCES:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON1;
|
|
break;
|
|
case INTERFACE_CONNECTION_FAILURE:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON2;
|
|
break;
|
|
case INTERFACE_DISABLED:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON3;
|
|
break;
|
|
case INTERFACE_SERVICE_IS_PAUSED:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON4;
|
|
break;
|
|
case INTERFACE_DIALOUT_HOURS_RESTRICTION:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON5;
|
|
break;
|
|
case INTERFACE_NO_MEDIA_SENSE:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON6;
|
|
break;
|
|
case INTERFACE_NO_DEVICE:
|
|
dwEventLogId = ROUTERLOG_IF_UNREACHABLE_REASON7;
|
|
break;
|
|
default:
|
|
dwEventLogId = 0;
|
|
break;
|
|
}
|
|
|
|
if ( dwEventLogId != 0 )
|
|
{
|
|
DIMLogInformation( dwEventLogId, 1, &lpszFriendlyName );
|
|
}
|
|
}
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectIsLANDeviceActive
|
|
//
|
|
// Returns: NO_ERROR - Success
|
|
// Non-zero returns - Failure
|
|
//
|
|
// Description:
|
|
//
|
|
BOOL
|
|
IfObjectIsLANDeviceActive(
|
|
IN LPWSTR lpwsInterfaceName,
|
|
OUT LPDWORD lpdwInactiveReason
|
|
)
|
|
{
|
|
NETCON_STATUS NetConStatus;
|
|
HRESULT hResult;
|
|
BOOL fEnabled;
|
|
GUID Guid;
|
|
NTSTATUS NtStatus;
|
|
UNICODE_STRING usTemp;
|
|
|
|
//
|
|
// First check media state
|
|
//
|
|
|
|
usTemp.Length = wcslen(lpwsInterfaceName) * sizeof(WCHAR);
|
|
usTemp.MaximumLength = usTemp.Length + sizeof(WCHAR);
|
|
usTemp.Buffer = lpwsInterfaceName;
|
|
|
|
NtStatus = RtlGUIDFromString( &usTemp, &Guid );
|
|
|
|
if ( NtStatus != STATUS_SUCCESS )
|
|
{
|
|
*lpdwInactiveReason = INTERFACE_NO_DEVICE;
|
|
|
|
return( FALSE );
|
|
}
|
|
|
|
hResult = HrGetPnpDeviceStatus( &Guid, &NetConStatus );
|
|
|
|
if ( HRESULT_CODE( hResult ) == NO_ERROR )
|
|
{
|
|
switch ( NetConStatus )
|
|
{
|
|
case NCS_MEDIA_DISCONNECTED:
|
|
*lpdwInactiveReason = INTERFACE_NO_MEDIA_SENSE;
|
|
return( FALSE );
|
|
|
|
case NCS_CONNECTED:
|
|
case NCS_INVALID_ADDRESS:
|
|
case NCS_AUTHENTICATING:
|
|
case NCS_CREDENTIALS_REQUIRED:
|
|
case NCS_AUTHENTICATION_FAILED:
|
|
case NCS_AUTHENTICATION_SUCCEEDED:
|
|
{
|
|
return( TRUE );
|
|
}
|
|
|
|
default:
|
|
*lpdwInactiveReason = INTERFACE_NO_DEVICE;
|
|
return( FALSE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*lpdwInactiveReason = INTERFACE_NO_DEVICE;
|
|
return( FALSE );
|
|
}
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
//**
|
|
//
|
|
// Call: IfObjectDeleteInterface
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Description: Delete this interface with all the router managers.
|
|
//
|
|
//
|
|
VOID
|
|
IfObjectDeleteInterfaceFromTransport(
|
|
IN ROUTER_INTERFACE_OBJECT * pIfObject,
|
|
IN DWORD dwPid
|
|
)
|
|
{
|
|
DWORD dwIndex;
|
|
DIM_ROUTER_INTERFACE * pDdmRouterIf;
|
|
DWORD dwRetCode;
|
|
|
|
for ( dwIndex = 0;
|
|
dwIndex < gblDIMConfigInfo.dwNumRouterManagers;
|
|
dwIndex++ )
|
|
{
|
|
if ( pIfObject->Transport[dwIndex].hInterface == INVALID_HANDLE_VALUE )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pDdmRouterIf=&(gblRouterManagers[dwIndex].DdmRouterIf);
|
|
|
|
if ( pDdmRouterIf->dwProtocolId == dwPid )
|
|
{
|
|
dwRetCode = pDdmRouterIf->DeleteInterface(
|
|
pIfObject->Transport[dwIndex].hInterface );
|
|
|
|
if ( dwRetCode != NO_ERROR )
|
|
{
|
|
LPWSTR lpwsInsertStrings[2];
|
|
|
|
lpwsInsertStrings[0] = pIfObject->lpwsInterfaceName;
|
|
lpwsInsertStrings[1] = ( pDdmRouterIf->dwProtocolId == PID_IP )
|
|
? L"IP" : L"IPX";
|
|
|
|
DIMLogErrorString( ROUTERLOG_COULDNT_REMOVE_INTERFACE, 2,
|
|
lpwsInsertStrings, dwRetCode, 2 );
|
|
}
|
|
|
|
pIfObject->Transport[dwIndex].hInterface = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
}
|