1585 lines
37 KiB
C
1585 lines
37 KiB
C
/*++
|
|
|
|
Copyright (c) 1997 - 98, Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
rtmobj1.c
|
|
|
|
Abstract:
|
|
|
|
Contains routines for managing RTM objects
|
|
like Instances, AddrFamilies and Entities.
|
|
|
|
Author:
|
|
|
|
Chaitanya Kodeboyina (chaitk) 21-Aug-1998
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "pchrtm.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
|
|
DWORD
|
|
GetInstance (
|
|
IN USHORT RtmInstanceId,
|
|
IN BOOL ImplicitCreate,
|
|
OUT PINSTANCE_INFO *RtmInstance
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches for an RTM instance with the input instance
|
|
id. If an instance is not found and ImplicitCreate
|
|
is TRUE, then a new instance is created and added to
|
|
the table of instances.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - Id for RTM Instance being searched for,
|
|
|
|
ImplicitCreate - Create a new instance if not found or not,
|
|
|
|
RtmInstance - Pointer to the Instance Info Structure
|
|
will be returned through this parameter.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
The InstancesLock in RtmGlobals should be held while calling
|
|
this function. If ImplicitCreate is FALSE, a read lock would
|
|
do, but if it is TRUE then a write lock should be held as we
|
|
would need to insert a new instance into the instances list.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY Instances;
|
|
PINSTANCE_INFO Instance;
|
|
PLIST_ENTRY p;
|
|
DWORD Status;
|
|
|
|
Instances = &RtmGlobals.InstanceTable[RtmInstanceId % INSTANCE_TABLE_SIZE];
|
|
|
|
#if WRN
|
|
Instance = NULL;
|
|
#endif
|
|
|
|
do
|
|
{
|
|
// Search the global list for a matching instance
|
|
for (p = Instances->Flink; p != Instances; p = p->Flink)
|
|
{
|
|
Instance = CONTAINING_RECORD(p, INSTANCE_INFO, InstTableLE);
|
|
|
|
if (Instance->RtmInstanceId >= RtmInstanceId)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((p == Instances) || (Instance->RtmInstanceId != RtmInstanceId))
|
|
{
|
|
// We did not find an instance - create new one ?
|
|
if (!ImplicitCreate)
|
|
{
|
|
Status = ERROR_NOT_FOUND;
|
|
break;
|
|
}
|
|
|
|
// Create a new instance with input Instance id
|
|
Status = CreateInstance(RtmInstanceId, &Instance);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Insert into list in sorted Instance Id order
|
|
InsertTailList(p, &Instance->InstTableLE);
|
|
}
|
|
|
|
Status = NO_ERROR;
|
|
|
|
*RtmInstance = Instance;
|
|
}
|
|
while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
CreateInstance (
|
|
IN USHORT RtmInstanceId,
|
|
OUT PINSTANCE_INFO *NewInstance
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a new instance info structure and initializes it.
|
|
|
|
Arguments:
|
|
|
|
RtmInstanceId - RTM Instance Id for the new RTM instance,
|
|
|
|
InstConfig - Configuration Info for the new instance,
|
|
|
|
NewInstance - Pointer to the Instance Info Structure
|
|
will be returned through this parameter.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
Need to be called with the instances WRITE lock as we are
|
|
incrementing the number of instances here.
|
|
|
|
--*/
|
|
|
|
{
|
|
RTM_INSTANCE_CONFIG InstConfig;
|
|
PINSTANCE_INFO Instance;
|
|
DWORD Status;
|
|
|
|
*NewInstance = NULL;
|
|
|
|
//
|
|
// Read Instance Configuration from the registry
|
|
//
|
|
|
|
Status = RtmReadInstanceConfig(RtmInstanceId, &InstConfig);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Allocate and initialize a new instance info
|
|
//
|
|
|
|
Instance = (PINSTANCE_INFO) AllocNZeroObject(sizeof(INSTANCE_INFO));
|
|
|
|
if (Instance == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
#if DBG_HDL
|
|
Instance->ObjectHeader.TypeSign = INSTANCE_ALLOC;
|
|
#endif
|
|
|
|
// Will be removed when last addr family goes
|
|
INITIALIZE_INSTANCE_REFERENCE(Instance, CREATION_REF);
|
|
|
|
Instance->RtmInstanceId = RtmInstanceId;
|
|
|
|
//
|
|
// Linking instance to global list of instances is
|
|
// done by caller, but pretend it is already done
|
|
//
|
|
|
|
RtmGlobals.NumInstances++;
|
|
|
|
InitializeListHead(&Instance->InstTableLE);
|
|
|
|
//
|
|
// Initialize the table of address families
|
|
//
|
|
|
|
Instance->NumAddrFamilies = 0;
|
|
|
|
InitializeListHead(&Instance->AddrFamilyTable);
|
|
|
|
*NewInstance = Instance;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DestroyInstance (
|
|
IN PINSTANCE_INFO Instance
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destroys an existing instance info structure. Assumes that
|
|
no registered entities exist on this instance when called.
|
|
|
|
Arguments:
|
|
|
|
Instance - Pointer to the Instance Info Structure.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
The InstancesLock in RtmGlobals should be held while calling
|
|
this function as it removes an instance from that list. This
|
|
is typically taken in DestroyEntity, but it can also happen
|
|
that the lock is acquired in RtmRegisterEntity and an error
|
|
occured.
|
|
|
|
--*/
|
|
|
|
{
|
|
ASSERT(Instance->ObjectHeader.RefCount == 0);
|
|
|
|
ASSERT(Instance->NumAddrFamilies == 0);
|
|
|
|
//
|
|
// Remove this instance from list of instances
|
|
//
|
|
|
|
RemoveEntryList(&Instance->InstTableLE);
|
|
|
|
RtmGlobals.NumInstances--;
|
|
|
|
//
|
|
// Free resources allocated for this instance
|
|
//
|
|
|
|
#if DBG_HDL
|
|
Instance->ObjectHeader.TypeSign = INSTANCE_FREED;
|
|
#endif
|
|
|
|
FreeObject(Instance);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GetAddressFamily (
|
|
IN PINSTANCE_INFO Instance,
|
|
IN USHORT AddressFamily,
|
|
IN BOOL ImplicitCreate,
|
|
OUT PADDRFAM_INFO *AddrFamilyInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches for an address family in an RTM instance.
|
|
If it is not found and ImplicitCreate is TRUE, then
|
|
a new address family info is created and added to
|
|
the list of address families.
|
|
|
|
Arguments:
|
|
|
|
Instance - RTM Instance that holds the address family,
|
|
|
|
AddressFamily - Address family for info being searched for,
|
|
|
|
ImplicitCreate - Create an addr family info if not found or not,
|
|
|
|
AddrFamilyInfo - Pointer to the new Address Family Info
|
|
will be returned through this parameter.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
The InstancesLock in RtmGlobals should be held while calling
|
|
this function. If ImplicitCreate is FALSE, a read lock would
|
|
do, but if it is TRUE then a write lock should be held as we
|
|
will need it to insert a new address family info into a list.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY AddrFams;
|
|
PADDRFAM_INFO AddrFamInfo;
|
|
PLIST_ENTRY q;
|
|
DWORD Status;
|
|
|
|
AddrFams = &Instance->AddrFamilyTable;
|
|
|
|
#if WRN
|
|
AddrFamInfo = NULL;
|
|
#endif
|
|
|
|
do
|
|
{
|
|
// Search the list of addr families on instance
|
|
for (q = AddrFams->Flink; q != AddrFams; q = q->Flink)
|
|
{
|
|
AddrFamInfo = CONTAINING_RECORD(q, ADDRFAM_INFO, AFTableLE);
|
|
|
|
if (AddrFamInfo->AddressFamily >= AddressFamily)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((q == AddrFams) || (AddrFamInfo->AddressFamily != AddressFamily))
|
|
{
|
|
// We did not find an instance - create new one ?
|
|
if (!ImplicitCreate)
|
|
{
|
|
Status = ERROR_NOT_FOUND;
|
|
break;
|
|
}
|
|
|
|
// Create a new addr family info with input family
|
|
Status = CreateAddressFamily(Instance,AddressFamily, &AddrFamInfo);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Insert into list sorted in Address Family order
|
|
InsertTailList(q, &AddrFamInfo->AFTableLE);
|
|
}
|
|
|
|
Status = NO_ERROR;
|
|
|
|
*AddrFamilyInfo = AddrFamInfo;
|
|
}
|
|
while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
CreateAddressFamily (
|
|
IN PINSTANCE_INFO Instance,
|
|
IN USHORT AddressFamily,
|
|
OUT PADDRFAM_INFO *NewAddrFamilyInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a new address family info and initializes it
|
|
|
|
Arguments:
|
|
|
|
Instance - RTM Instance that owns addr family info,
|
|
|
|
AddressFamily - Address family for the new info block,
|
|
|
|
AddrFamilyInfo - Pointer to the new Address Family Info
|
|
will be returned through this parameter.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
Need to be called with the instances WRITE lock as we are
|
|
are incrementing number of address families on instance.
|
|
|
|
--*/
|
|
|
|
{
|
|
RTM_ADDRESS_FAMILY_CONFIG AddrFamConfig;
|
|
PADDRFAM_INFO AddrFamilyInfo;
|
|
RTM_VIEW_SET ViewsSupported;
|
|
PSINGLE_LIST_ENTRY ListPtr;
|
|
UINT i;
|
|
DWORD Status;
|
|
|
|
*NewAddrFamilyInfo = NULL;
|
|
|
|
//
|
|
// Read AddressFamily Configuration from the registry
|
|
//
|
|
|
|
Status = RtmReadAddressFamilyConfig(Instance->RtmInstanceId,
|
|
AddressFamily,
|
|
&AddrFamConfig);
|
|
if (Status != NO_ERROR)
|
|
{
|
|
if (Instance->NumAddrFamilies == 0)
|
|
{
|
|
DEREFERENCE_INSTANCE(Instance, CREATION_REF);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// Allocate and initialize a new address family info
|
|
//
|
|
|
|
AddrFamilyInfo = (PADDRFAM_INFO) AllocNZeroObject(sizeof(ADDRFAM_INFO));
|
|
|
|
if (AddrFamilyInfo == NULL)
|
|
{
|
|
if (Instance->NumAddrFamilies == 0)
|
|
{
|
|
DEREFERENCE_INSTANCE(Instance, CREATION_REF);
|
|
}
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
|
|
do
|
|
{
|
|
#if DBG_HDL
|
|
AddrFamilyInfo->ObjectHeader.TypeSign = ADDRESS_FAMILY_ALLOC;
|
|
#endif
|
|
|
|
// Will be removed when last entity deregisters
|
|
INITIALIZE_ADDR_FAMILY_REFERENCE(AddrFamilyInfo, CREATION_REF);
|
|
|
|
AddrFamilyInfo->AddressFamily = AddressFamily;
|
|
|
|
AddrFamilyInfo->AddressSize = AddrFamConfig.AddressSize;
|
|
|
|
AddrFamilyInfo->Instance = Instance;
|
|
|
|
REFERENCE_INSTANCE(Instance, ADDR_FAMILY_REF);
|
|
|
|
//
|
|
// Linking the address family to its owning instance
|
|
// is done by caller, but pretend it is already done
|
|
//
|
|
|
|
Instance->NumAddrFamilies++;
|
|
|
|
InitializeListHead(&AddrFamilyInfo->AFTableLE);
|
|
|
|
//
|
|
// Count number of views supported by this addr family
|
|
// & setup the view id <-> view index in dest mappings
|
|
//
|
|
|
|
AddrFamilyInfo->ViewsSupported = AddrFamConfig.ViewsSupported;
|
|
|
|
ViewsSupported = AddrFamConfig.ViewsSupported;
|
|
AddrFamilyInfo->NumberOfViews = 0;
|
|
|
|
for (i = 0; i < RTM_MAX_VIEWS; i++)
|
|
{
|
|
AddrFamilyInfo->ViewIdFromIndex[i] = -1;
|
|
AddrFamilyInfo->ViewIndexFromId[i] = -1;
|
|
}
|
|
|
|
for (i = 0; (i < RTM_MAX_VIEWS) && ViewsSupported; i++)
|
|
{
|
|
if (ViewsSupported & 0x01)
|
|
{
|
|
AddrFamilyInfo->ViewIdFromIndex[AddrFamilyInfo->NumberOfViews]
|
|
= i;
|
|
|
|
AddrFamilyInfo->ViewIndexFromId[i] =
|
|
AddrFamilyInfo->NumberOfViews;
|
|
|
|
AddrFamilyInfo->NumberOfViews++;
|
|
}
|
|
|
|
ViewsSupported >>= 1;
|
|
}
|
|
|
|
AddrFamilyInfo->MaxHandlesInEnum = AddrFamConfig.MaxHandlesInEnum;
|
|
|
|
AddrFamilyInfo->MaxNextHopsInRoute = AddrFamConfig.MaxNextHopsInRoute;
|
|
|
|
//
|
|
// Initialize the opaque pointer's directory
|
|
//
|
|
|
|
AddrFamilyInfo->MaxOpaquePtrs = AddrFamConfig.MaxOpaqueInfoPtrs;
|
|
AddrFamilyInfo->NumOpaquePtrs = 0;
|
|
|
|
AddrFamilyInfo->OpaquePtrsDir =
|
|
AllocNZeroMemory(AddrFamilyInfo->MaxOpaquePtrs * sizeof(PVOID));
|
|
|
|
if (AddrFamilyInfo->OpaquePtrsDir == NULL)
|
|
{
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize the list of entities on this address family
|
|
//
|
|
|
|
AddrFamilyInfo->NumEntities = 0;
|
|
for (i = 0; i < ENTITY_TABLE_SIZE; i++)
|
|
{
|
|
InitializeListHead(&AddrFamilyInfo->EntityTable[i]);
|
|
}
|
|
|
|
//
|
|
// Init list of entities de-registered but not destroyed
|
|
//
|
|
|
|
InitializeListHead(&AddrFamilyInfo->DeregdEntities);
|
|
|
|
//
|
|
// Initialize the route table and route table lock
|
|
//
|
|
|
|
try
|
|
{
|
|
CREATE_READ_WRITE_LOCK(&AddrFamilyInfo->RouteTableLock);
|
|
|
|
AddrFamilyInfo->RoutesLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
Status = CreateTable(AddrFamilyInfo->AddressSize,
|
|
&AddrFamilyInfo->RouteTable);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize queue to hold notification timers
|
|
//
|
|
|
|
AddrFamilyInfo->NotifTimerQueue = CreateTimerQueue();
|
|
|
|
if (AddrFamilyInfo->NotifTimerQueue == NULL)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize queue to hold route timers on AF
|
|
//
|
|
|
|
AddrFamilyInfo->RouteTimerQueue = CreateTimerQueue();
|
|
|
|
if (AddrFamilyInfo->RouteTimerQueue == NULL)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize the change notification info and lock
|
|
//
|
|
|
|
try
|
|
{
|
|
CREATE_READ_WRITE_LOCK(&AddrFamilyInfo->ChangeNotifsLock);
|
|
|
|
AddrFamilyInfo->NotifsLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
AddrFamilyInfo->MaxChangeNotifs = AddrFamConfig.MaxChangeNotifyRegns;
|
|
AddrFamilyInfo->NumChangeNotifs = 0;
|
|
|
|
//
|
|
// Allocate memory for the max number of notifications
|
|
//
|
|
|
|
AddrFamilyInfo->ChangeNotifsDir =
|
|
AllocNZeroMemory(AddrFamilyInfo->MaxChangeNotifs *
|
|
sizeof(PVOID));
|
|
|
|
if (AddrFamilyInfo->ChangeNotifsDir == NULL)
|
|
{
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize lock protecting the notification timer
|
|
//
|
|
|
|
try
|
|
{
|
|
InitializeCriticalSection(&AddrFamilyInfo->NotifsTimerLock);
|
|
|
|
AddrFamilyInfo->TimerLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize each change list in the change list table
|
|
//
|
|
|
|
for (i = 0; i < NUM_CHANGED_DEST_LISTS; i++)
|
|
{
|
|
//
|
|
// Initialize the list of changed dests and lock
|
|
//
|
|
|
|
// Init the change list to an empty circular list
|
|
|
|
ListPtr = &AddrFamilyInfo->ChangeLists[i].ChangedDestsHead;
|
|
|
|
ListPtr->Next = ListPtr;
|
|
|
|
AddrFamilyInfo->ChangeLists[i].ChangedDestsTail = ListPtr;
|
|
|
|
try
|
|
{
|
|
InitializeCriticalSection
|
|
(&AddrFamilyInfo->ChangeLists[i].ChangesListLock);
|
|
|
|
AddrFamilyInfo->ChangeLists[i].ChangesLockInited = TRUE;
|
|
|
|
continue;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
*NewAddrFamilyInfo = AddrFamilyInfo;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while (FALSE);
|
|
|
|
//
|
|
// Something failed - undo work done and return status
|
|
//
|
|
|
|
DEREFERENCE_ADDR_FAMILY(AddrFamilyInfo, CREATION_REF);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DestroyAddressFamily (
|
|
IN PADDRFAM_INFO AddrFamilyInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destroys an address family info in an RTM instance.
|
|
Assumes that no registered entities exist with this
|
|
address family in this RTM instance when invoked.
|
|
|
|
This function has been written such that it can be
|
|
called when an error occurs in CreateAddressFamily.
|
|
|
|
Arguments:
|
|
|
|
AddrFamilyInfo - Pointer to the Rib Info Structure.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
The InstancesLock in RtmGlobals should be held while calling
|
|
this function as it removes an address family from the list
|
|
of address families on the instance. This lock is typically
|
|
taken in DestroyEntity, but it can also happen that the lock
|
|
is acquired in RtmRegisterEntity and an error occured in the
|
|
CreateAddressFamily function.
|
|
|
|
--*/
|
|
|
|
{
|
|
PINSTANCE_INFO Instance;
|
|
PSINGLE_LIST_ENTRY ListPtr;
|
|
UINT i;
|
|
|
|
ASSERT(AddrFamilyInfo->ObjectHeader.RefCount == 0);
|
|
|
|
ASSERT(AddrFamilyInfo->NumEntities == 0);
|
|
|
|
ASSERT(IsListEmpty(&AddrFamilyInfo->DeregdEntities));
|
|
|
|
//
|
|
// Block until timers on address family are cleaned up
|
|
//
|
|
|
|
if (AddrFamilyInfo->RouteTimerQueue)
|
|
{
|
|
DeleteTimerQueueEx(AddrFamilyInfo->RouteTimerQueue, (HANDLE) -1);
|
|
}
|
|
|
|
if (AddrFamilyInfo->NotifTimerQueue)
|
|
{
|
|
DeleteTimerQueueEx(AddrFamilyInfo->NotifTimerQueue, (HANDLE) -1);
|
|
}
|
|
|
|
//
|
|
// Free resources allocated to the change lists (locks ..)
|
|
//
|
|
|
|
// No more dests in change list as all entities are gone
|
|
|
|
ASSERT(AddrFamilyInfo->NumChangedDests == 0);
|
|
|
|
for (i = 0; i < NUM_CHANGED_DEST_LISTS; i++)
|
|
{
|
|
ListPtr = &AddrFamilyInfo->ChangeLists[i].ChangedDestsHead;
|
|
|
|
ASSERT(ListPtr->Next == ListPtr);
|
|
|
|
ASSERT(AddrFamilyInfo->ChangeLists[i].ChangedDestsTail == ListPtr);
|
|
|
|
if (AddrFamilyInfo->ChangeLists[i].ChangesLockInited)
|
|
{
|
|
DeleteCriticalSection
|
|
(&AddrFamilyInfo->ChangeLists[i].ChangesListLock);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Free the change notification info and the guarding lock
|
|
//
|
|
|
|
ASSERT(AddrFamilyInfo->NumChangeNotifs == 0);
|
|
|
|
if (AddrFamilyInfo->ChangeNotifsDir)
|
|
{
|
|
FreeMemory(AddrFamilyInfo->ChangeNotifsDir);
|
|
}
|
|
|
|
if (AddrFamilyInfo->NotifsLockInited)
|
|
{
|
|
DELETE_READ_WRITE_LOCK(&AddrFamilyInfo->ChangeNotifsLock);
|
|
}
|
|
|
|
//
|
|
// Free the lock guarding the notification timer
|
|
//
|
|
|
|
if (AddrFamilyInfo->TimerLockInited)
|
|
{
|
|
DeleteCriticalSection(&AddrFamilyInfo->NotifsTimerLock);
|
|
}
|
|
|
|
//
|
|
// Free the route table and the route table lock
|
|
//
|
|
|
|
ASSERT(AddrFamilyInfo->NumRoutes == 0);
|
|
|
|
//
|
|
// Because some hold's are left out - this count
|
|
// might not be equal to zero. Need to fix this
|
|
// memory leak by cleaning up before this point
|
|
//
|
|
// ASSERT(AddrFamilyInfo->NumDests == 0);
|
|
|
|
if (AddrFamilyInfo->RouteTable)
|
|
{
|
|
DestroyTable(AddrFamilyInfo->RouteTable);
|
|
}
|
|
|
|
if (AddrFamilyInfo->RoutesLockInited)
|
|
{
|
|
DELETE_READ_WRITE_LOCK(&AddrFamilyInfo->RouteTableLock);
|
|
}
|
|
|
|
//
|
|
// Free Opaque Ptrs directory (if it is allocated)
|
|
//
|
|
|
|
if (AddrFamilyInfo->OpaquePtrsDir)
|
|
{
|
|
FreeMemory(AddrFamilyInfo->OpaquePtrsDir);
|
|
}
|
|
|
|
//
|
|
// Remove the address family from owning instance
|
|
//
|
|
|
|
Instance = AddrFamilyInfo->Instance;
|
|
|
|
RemoveEntryList(&AddrFamilyInfo->AFTableLE);
|
|
Instance->NumAddrFamilies--;
|
|
DEREFERENCE_INSTANCE(Instance, ADDR_FAMILY_REF);
|
|
|
|
// Reclaim the instance if it has no addr familes
|
|
|
|
if (Instance->NumAddrFamilies == 0)
|
|
{
|
|
DEREFERENCE_INSTANCE(Instance, CREATION_REF);
|
|
}
|
|
|
|
#if DBG_HDL
|
|
AddrFamilyInfo->ObjectHeader.TypeSign = ADDRESS_FAMILY_FREED;
|
|
#endif
|
|
|
|
FreeObject(AddrFamilyInfo);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GetEntity (
|
|
IN PADDRFAM_INFO AddrFamilyInfo,
|
|
IN ULONGLONG EntityId,
|
|
IN BOOL ImplicitCreate,
|
|
IN PRTM_ENTITY_INFO RtmEntityInfo OPTIONAL,
|
|
IN BOOL ReserveOpaquePtr OPTIONAL,
|
|
IN PRTM_ENTITY_EXPORT_METHODS ExportMethods OPTIONAL,
|
|
IN RTM_EVENT_CALLBACK EventCallback OPTIONAL,
|
|
OUT PENTITY_INFO *EntityInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches for an entity with a certain protocol id and
|
|
protocol instance. If it is not found and ImplicitCreate
|
|
is TRUE, then a new entity is created and added to the
|
|
table of entities on address family.
|
|
|
|
Arguments:
|
|
|
|
AddrFamilyInfo - Address family block that we are seaching,
|
|
|
|
EntityId - Entity protocol id and protocol instance,
|
|
|
|
ImplicitCreate - Create a new entity if not found or not,
|
|
|
|
For all others - See corresponding parametes in CreateEntity
|
|
|
|
EntityInfo - The entity info is returned in this param.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
Locks:
|
|
|
|
The InstancesLock in RtmGlobals should be held while calling
|
|
this function. If ImplicitCreate is FALSE, a read lock would
|
|
do, but if it is TRUE then a write lock should be held as we
|
|
would need it to insert a new entity into the entities list.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY Entities;
|
|
PENTITY_INFO Entity;
|
|
PLIST_ENTRY r;
|
|
DWORD Status;
|
|
|
|
Entities = &AddrFamilyInfo->EntityTable[EntityId % ENTITY_TABLE_SIZE];
|
|
|
|
#if WRN
|
|
Entity = NULL;
|
|
#endif
|
|
|
|
do
|
|
{
|
|
// Search for an entity with the input Entity Id
|
|
for (r = Entities->Flink; r != Entities; r = r->Flink)
|
|
{
|
|
Entity = CONTAINING_RECORD(r, ENTITY_INFO, EntityTableLE);
|
|
|
|
if (Entity->EntityId.EntityId >= EntityId)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((r != Entities) && (Entity->EntityId.EntityId == EntityId))
|
|
{
|
|
Status = ERROR_ALREADY_EXISTS;
|
|
break;
|
|
}
|
|
|
|
// We did not find an entity - create a new one ?
|
|
if (!ImplicitCreate)
|
|
{
|
|
Status = ERROR_NOT_FOUND;
|
|
break;
|
|
}
|
|
|
|
// Create a new entity with all the input RTM parameters
|
|
|
|
Status = CreateEntity(AddrFamilyInfo,
|
|
RtmEntityInfo,
|
|
ReserveOpaquePtr,
|
|
ExportMethods,
|
|
EventCallback,
|
|
&Entity);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Inform all existing entities of this new entity
|
|
//
|
|
|
|
InformEntitiesOfEvent(AddrFamilyInfo->EntityTable,
|
|
RTM_ENTITY_REGISTERED,
|
|
Entity);
|
|
|
|
// Insert to keep the list sorted Entity Id Order
|
|
InsertTailList(r, &Entity->EntityTableLE);
|
|
|
|
*EntityInfo = Entity;
|
|
}
|
|
while (FALSE);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
CreateEntity (
|
|
IN PADDRFAM_INFO AddrFamilyInfo,
|
|
IN PRTM_ENTITY_INFO EntityInfo,
|
|
IN BOOL ReserveOpaquePtr,
|
|
IN PRTM_ENTITY_EXPORT_METHODS ExportMethods,
|
|
IN RTM_EVENT_CALLBACK EventCallback,
|
|
OUT PENTITY_INFO *NewEntity
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a new entity info structure and initializes it.
|
|
|
|
Arguments:
|
|
|
|
AddrFamilyInfo - Address Family the entity is registering with,
|
|
|
|
EntityInfo - Information for the entity being created,
|
|
|
|
ReserveOpaquePtr - Reserve a ptr in each destination or not,
|
|
|
|
ExportMethods - List of methods exported by this entity,
|
|
|
|
EventCallback - Callback invoked to inform of certain events
|
|
like entity registrations, de-registrations,
|
|
|
|
NewEntity - Pointer to the new Entity Info structure
|
|
will be returned through this parameter.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
--*/
|
|
|
|
{
|
|
PENTITY_INFO Entity;
|
|
UINT NumMethods, i;
|
|
DWORD Status;
|
|
|
|
*NewEntity = NULL;
|
|
|
|
//
|
|
// Allocate and initialize a new entity info structure
|
|
//
|
|
|
|
NumMethods = ExportMethods ? ExportMethods->NumMethods : 0;
|
|
|
|
Entity = (PENTITY_INFO) AllocNZeroObject(
|
|
sizeof(ENTITY_INFO) +
|
|
(NumMethods ? (NumMethods - 1) : 0 ) *
|
|
sizeof(RTM_ENTITY_EXPORT_METHOD));
|
|
|
|
if (Entity == NULL)
|
|
{
|
|
if (AddrFamilyInfo->NumEntities == 0)
|
|
{
|
|
DEREFERENCE_ADDR_FAMILY(AddrFamilyInfo, CREATION_REF);
|
|
}
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
do
|
|
{
|
|
#if DBG_HDL
|
|
Entity->ObjectHeader.TypeSign = ENTITY_ALLOC;
|
|
#endif
|
|
INITIALIZE_ENTITY_REFERENCE(Entity, CREATION_REF);
|
|
|
|
Entity->EntityId = EntityInfo->EntityId;
|
|
|
|
Entity->OwningAddrFamily = AddrFamilyInfo;
|
|
REFERENCE_ADDR_FAMILY(AddrFamilyInfo, ENTITY_REF);
|
|
|
|
//
|
|
// Linking the entity to its owning address family is
|
|
// done by caller,but pretend that it is already done
|
|
//
|
|
|
|
AddrFamilyInfo->NumEntities++;
|
|
|
|
InitializeListHead(&Entity->EntityTableLE);
|
|
|
|
//
|
|
// Allocate an opaque pointer index if asked for
|
|
//
|
|
|
|
Entity->OpaquePtrOffset = -1;
|
|
|
|
if (ReserveOpaquePtr)
|
|
{
|
|
if (AddrFamilyInfo->NumOpaquePtrs >= AddrFamilyInfo->MaxOpaquePtrs)
|
|
{
|
|
Status = ERROR_NO_SYSTEM_RESOURCES;
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < AddrFamilyInfo->MaxOpaquePtrs; i++)
|
|
{
|
|
if (AddrFamilyInfo->OpaquePtrsDir[i] == NULL)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
AddrFamilyInfo->OpaquePtrsDir[i] = (PVOID) Entity;
|
|
|
|
AddrFamilyInfo->NumOpaquePtrs++;
|
|
|
|
Entity->OpaquePtrOffset = i;
|
|
|
|
ASSERT(Entity->OpaquePtrOffset != -1);
|
|
}
|
|
|
|
//
|
|
// Initialize lock guarding entity-specific route lists
|
|
//
|
|
|
|
try
|
|
{
|
|
CREATE_READ_WRITE_LOCK(&Entity->RouteListsLock);
|
|
|
|
Entity->ListsLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialize the list of open handles and corresponding lock
|
|
//
|
|
|
|
try
|
|
{
|
|
InitializeCriticalSection(&Entity->OpenHandlesLock);
|
|
|
|
Entity->HandlesLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
InitializeListHead(&Entity->OpenHandles);
|
|
|
|
//
|
|
// Initialize the next hop table and the next hop table lock
|
|
//
|
|
|
|
try
|
|
{
|
|
CREATE_READ_WRITE_LOCK(&Entity->NextHopTableLock);
|
|
|
|
Entity->NextHopsLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
Status = CreateTable(AddrFamilyInfo->AddressSize,
|
|
&Entity->NextHopTable);
|
|
|
|
if (Status != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
Entity->NumNextHops = 0;
|
|
|
|
//
|
|
// Initialize entity methods and the entity methods lock
|
|
//
|
|
|
|
try
|
|
{
|
|
CREATE_READ_WRITE_LOCK(&Entity->EntityMethodsLock);
|
|
|
|
Entity->MethodsLockInited = TRUE;
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
Entity->EventCallback = EventCallback;
|
|
|
|
Entity->EntityMethods.NumMethods = NumMethods;
|
|
|
|
if (ExportMethods)
|
|
{
|
|
CopyMemory(Entity->EntityMethods.Methods,
|
|
ExportMethods->Methods,
|
|
NumMethods * sizeof(RTM_ENTITY_EXPORT_METHOD));
|
|
}
|
|
|
|
*NewEntity = Entity;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
while(FALSE);
|
|
|
|
//
|
|
// Something failed - undo work done and return status
|
|
//
|
|
|
|
DEREFERENCE_ENTITY(Entity, CREATION_REF);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DestroyEntity (
|
|
IN PENTITY_INFO Entity
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destroys an existing entity info structure. Frees
|
|
all associated resources before de-allocation.
|
|
|
|
This function has been written such that it can be
|
|
called when an error occurs during CreateEntity.
|
|
|
|
Arguments:
|
|
|
|
EntityInfo - Pointer to the Entity Info Structure.
|
|
|
|
Return Value:
|
|
|
|
Status of the operation
|
|
|
|
--*/
|
|
|
|
{
|
|
PADDRFAM_INFO AddrFamilyInfo;
|
|
|
|
ASSERT(Entity->ObjectHeader.RefCount == 0);
|
|
|
|
//
|
|
// Take globals registrations lock while cleaning up
|
|
//
|
|
|
|
ACQUIRE_INSTANCES_WRITE_LOCK();
|
|
|
|
//
|
|
// Free lock used to block exported entity methods
|
|
//
|
|
|
|
if (Entity->MethodsLockInited)
|
|
{
|
|
DELETE_READ_WRITE_LOCK(&Entity->EntityMethodsLock);
|
|
}
|
|
|
|
//
|
|
// Free the next hop table and the lock guarding it
|
|
//
|
|
|
|
ASSERT(Entity->NumNextHops == 0);
|
|
|
|
if (Entity->NextHopTable)
|
|
{
|
|
DestroyTable(Entity->NextHopTable);
|
|
}
|
|
|
|
if (Entity->NextHopsLockInited)
|
|
{
|
|
DELETE_READ_WRITE_LOCK(&Entity->NextHopTableLock);
|
|
}
|
|
|
|
if (Entity->HandlesLockInited)
|
|
{
|
|
// There should not be any handles opened by entity
|
|
|
|
ASSERT(IsListEmpty(&Entity->OpenHandles));
|
|
|
|
DeleteCriticalSection(&Entity->OpenHandlesLock);
|
|
}
|
|
|
|
//
|
|
// Free lock used to perform route list operations
|
|
//
|
|
|
|
if (Entity->ListsLockInited)
|
|
{
|
|
DELETE_READ_WRITE_LOCK(&Entity->RouteListsLock);
|
|
}
|
|
|
|
//
|
|
// Free the opaque ptr index in the address family
|
|
//
|
|
|
|
AddrFamilyInfo = Entity->OwningAddrFamily;
|
|
|
|
if (Entity->OpaquePtrOffset != -1)
|
|
{
|
|
AddrFamilyInfo->OpaquePtrsDir[Entity->OpaquePtrOffset] = NULL;
|
|
|
|
AddrFamilyInfo->NumOpaquePtrs--;
|
|
}
|
|
|
|
#if DBG_REF
|
|
|
|
//
|
|
// Signal event on entity to unblock de-register
|
|
// The evnt will be freed in RtmDeregisterEntity
|
|
//
|
|
|
|
if (Entity->BlockingEvent)
|
|
{
|
|
SetEvent(Entity->BlockingEvent);
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Remove the entity from the owning address family
|
|
//
|
|
|
|
RemoveEntryList(&Entity->EntityTableLE);
|
|
AddrFamilyInfo->NumEntities--;
|
|
DEREFERENCE_ADDR_FAMILY(AddrFamilyInfo, ENTITY_REF);
|
|
|
|
// Reclaim the addr family if it has no entities
|
|
|
|
if (AddrFamilyInfo->NumEntities == 0)
|
|
{
|
|
DEREFERENCE_ADDR_FAMILY(AddrFamilyInfo, CREATION_REF);
|
|
}
|
|
|
|
#if DBG_HDL
|
|
Entity->ObjectHeader.TypeSign = ENTITY_FREED;
|
|
#endif
|
|
|
|
FreeObject(Entity);
|
|
|
|
RELEASE_INSTANCES_WRITE_LOCK();
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
VOID
|
|
InformEntitiesOfEvent (
|
|
IN PLIST_ENTRY EntityTable,
|
|
IN RTM_EVENT_TYPE EventType,
|
|
IN PENTITY_INFO EntityThis
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Informs all entities in the entity table that a certain
|
|
event has occured - like a new entity registered, or an
|
|
existing entity de-registered.
|
|
|
|
Arguments:
|
|
|
|
EntityTable - Pointer to the hash table of entities,
|
|
|
|
EventType - Type of the event being notified about,
|
|
|
|
EntityThis - Entity that caused the event to occur.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
Locks:
|
|
|
|
The instances lock has to be held in either write or
|
|
read mode as we are traversing the list of entities
|
|
on the address family.
|
|
|
|
--*/
|
|
|
|
{
|
|
RTM_ENTITY_HANDLE EntityHandle;
|
|
PADDRFAM_INFO AddrFamInfo;
|
|
RTM_ENTITY_INFO EntityInfo;
|
|
PENTITY_INFO Entity;
|
|
UINT i;
|
|
PLIST_ENTRY Entities, q;
|
|
|
|
//
|
|
// Prepare arguments for the Event Callbacks in loop
|
|
//
|
|
|
|
AddrFamInfo = EntityThis->OwningAddrFamily;
|
|
|
|
EntityInfo.RtmInstanceId = AddrFamInfo->Instance->RtmInstanceId;
|
|
EntityInfo.AddressFamily = AddrFamInfo->AddressFamily;
|
|
|
|
EntityInfo.EntityId = EntityThis->EntityId;
|
|
|
|
EntityHandle = MAKE_HANDLE_FROM_POINTER(EntityThis);
|
|
|
|
|
|
//
|
|
// For each entity in table, call its event callback
|
|
//
|
|
|
|
for (i = 0; i < ENTITY_TABLE_SIZE; i++)
|
|
{
|
|
Entities = &EntityTable[i];
|
|
|
|
for (q = Entities->Flink; q != Entities; q = q->Flink)
|
|
{
|
|
Entity = CONTAINING_RECORD(q, ENTITY_INFO, EntityTableLE);
|
|
|
|
//
|
|
// Inform the current entity of the event
|
|
// if it has an event handler registered
|
|
//
|
|
|
|
if (Entity->EventCallback)
|
|
{
|
|
//
|
|
// This callback should not call any of the registration
|
|
// APIs as it might result in corrupting the entity list
|
|
//
|
|
|
|
Entity->EventCallback(MAKE_HANDLE_FROM_POINTER(Entity),
|
|
EventType,
|
|
EntityHandle,
|
|
&EntityInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
CleanupAfterDeregister (
|
|
IN PENTITY_INFO Entity
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Cleans up all enums, notifications and entity lists
|
|
opened by an entity. Also deletes all nexthops and
|
|
routes owned by this entity. Assumes that the entity
|
|
is not making any other operations in parallel.
|
|
|
|
Arguments:
|
|
|
|
Entity - Pointer to the entity registration info.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
RTM_ENTITY_HANDLE RtmRegHandle;
|
|
PADDRFAM_INFO AddrFamInfo;
|
|
PHANDLE Handles;
|
|
RTM_ENUM_HANDLE EnumHandle;
|
|
UINT NumHandles, i;
|
|
DWORD ChangeFlags;
|
|
DWORD Status;
|
|
|
|
AddrFamInfo = Entity->OwningAddrFamily;
|
|
|
|
RtmRegHandle = MAKE_HANDLE_FROM_POINTER(Entity);
|
|
|
|
#if DBG_HDL
|
|
|
|
// ACQUIRE_OPEN_HANDLES_LOCK(Entity);
|
|
|
|
while (!IsListEmpty(&Entity->OpenHandles))
|
|
{
|
|
POPEN_HEADER OpenHeader;
|
|
HANDLE OpenHandle;
|
|
PLIST_ENTRY p;
|
|
|
|
p = RemoveHeadList(&Entity->OpenHandles);
|
|
|
|
OpenHeader = CONTAINING_RECORD(p, OPEN_HEADER, HandlesLE);
|
|
|
|
OpenHandle = MAKE_HANDLE_FROM_POINTER(OpenHeader);
|
|
|
|
switch (OpenHeader->HandleType)
|
|
{
|
|
case DEST_ENUM_TYPE:
|
|
case ROUTE_ENUM_TYPE:
|
|
case NEXTHOP_ENUM_TYPE:
|
|
case LIST_ENUM_TYPE:
|
|
|
|
Status = RtmDeleteEnumHandle(RtmRegHandle, OpenHandle);
|
|
break;
|
|
|
|
case NOTIFY_TYPE:
|
|
|
|
Status = RtmDeregisterFromChangeNotification(RtmRegHandle,
|
|
OpenHandle);
|
|
break;
|
|
|
|
case ROUTE_LIST_TYPE:
|
|
|
|
Status = RtmDeleteRouteList(RtmRegHandle, OpenHandle);
|
|
break;
|
|
|
|
default:
|
|
|
|
Status = ERROR_INVALID_DATA;
|
|
}
|
|
|
|
ASSERT(Status == NO_ERROR);
|
|
}
|
|
|
|
// RELEASE_OPEN_HANDLES_LOCK(Entity);
|
|
|
|
#endif // DBG_HDL
|
|
|
|
Handles = AllocMemory(AddrFamInfo->MaxHandlesInEnum * sizeof(HANDLE));
|
|
if ( Handles == NULL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Delete all routes created by this entity regn
|
|
//
|
|
|
|
Status = RtmCreateRouteEnum(RtmRegHandle,
|
|
NULL,
|
|
RTM_VIEW_MASK_ANY,
|
|
RTM_ENUM_OWN_ROUTES,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
&EnumHandle);
|
|
|
|
while (Status == NO_ERROR)
|
|
{
|
|
NumHandles = AddrFamInfo->MaxHandlesInEnum;
|
|
|
|
Status = RtmGetEnumRoutes(RtmRegHandle,
|
|
EnumHandle,
|
|
&NumHandles,
|
|
Handles);
|
|
|
|
for (i = 0; i < NumHandles; i++)
|
|
{
|
|
Status = RtmDeleteRouteToDest(RtmRegHandle,
|
|
Handles[i],
|
|
&ChangeFlags);
|
|
ASSERT(Status == NO_ERROR);
|
|
}
|
|
}
|
|
|
|
Status = RtmDeleteEnumHandle(RtmRegHandle,
|
|
EnumHandle);
|
|
|
|
ASSERT(Status == NO_ERROR);
|
|
|
|
|
|
//
|
|
// Delete all nexthops created by this entity regn
|
|
//
|
|
|
|
Status = RtmCreateNextHopEnum(RtmRegHandle,
|
|
0,
|
|
NULL,
|
|
&EnumHandle);
|
|
|
|
while (Status == NO_ERROR)
|
|
{
|
|
NumHandles = AddrFamInfo->MaxHandlesInEnum;
|
|
|
|
Status = RtmGetEnumNextHops(RtmRegHandle,
|
|
EnumHandle,
|
|
&NumHandles,
|
|
Handles);
|
|
|
|
for (i = 0; i < NumHandles; i++)
|
|
{
|
|
Status = RtmDeleteNextHop(RtmRegHandle,
|
|
Handles[i],
|
|
NULL);
|
|
|
|
ASSERT(Status == NO_ERROR);
|
|
}
|
|
}
|
|
|
|
Status = RtmDeleteEnumHandle(RtmRegHandle,
|
|
EnumHandle);
|
|
|
|
ASSERT(Status == NO_ERROR);
|
|
|
|
return;
|
|
}
|