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.
1511 lines
41 KiB
1511 lines
41 KiB
//============================================================================
|
|
// Copyright (c) 1995, Microsoft Corporation
|
|
//
|
|
// File: enum.c
|
|
//
|
|
// History:
|
|
// V Raman June-25-1997 Created.
|
|
//
|
|
// Enumeration functions exported to IP Router Manager.
|
|
//============================================================================
|
|
|
|
|
|
#include "pchmgm.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
DWORD
|
|
GetGroupMfes(
|
|
IN PGROUP_ENTRY pge,
|
|
IN DWORD dwStartSource,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN DWORD dwBufferSize,
|
|
IN OUT PDWORD pdwSize,
|
|
IN OUT PDWORD pdwNumEntries,
|
|
IN BOOL bIncludeFirst,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
|
|
VOID
|
|
CopyMfe(
|
|
IN PGROUP_ENTRY pge,
|
|
IN PSOURCE_ENTRY pse,
|
|
IN OUT PBYTE pb,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
|
|
|
|
//
|
|
// MFE enumeration
|
|
//
|
|
|
|
//----------------------------------------------------------------------------
|
|
// GetNextMfe
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
GetMfe(
|
|
IN PMIB_IPMCAST_MFE pmimm,
|
|
IN OUT PDWORD pdwBufferSize,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN DWORD dwFlags
|
|
)
|
|
{
|
|
|
|
BOOL bGrpLock = FALSE, bGrpEntryLock = FALSE;
|
|
|
|
DWORD dwErr = NO_ERROR, dwGrpBucket, dwSrcBucket, dwSizeReqd,
|
|
dwInd;
|
|
|
|
PGROUP_ENTRY pge;
|
|
|
|
PSOURCE_ENTRY pse;
|
|
|
|
POUT_IF_ENTRY poie;
|
|
|
|
PLIST_ENTRY ple, pleHead;
|
|
|
|
|
|
|
|
TRACEENUM3(
|
|
ENUM, "ENTERED GetMfe : %x, %x, Stats : %x", pmimm-> dwGroup,
|
|
pmimm-> dwSource, dwFlags
|
|
);
|
|
|
|
do
|
|
{
|
|
//
|
|
// Find group entry
|
|
//
|
|
|
|
dwGrpBucket = GROUP_TABLE_HASH( pmimm-> dwGroup, 0 );
|
|
|
|
ACQUIRE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
bGrpLock = TRUE;
|
|
|
|
pleHead = GROUP_BUCKET_HEAD( dwGrpBucket );
|
|
|
|
pge = GetGroupEntry( pleHead, pmimm-> dwGroup, 0 );
|
|
|
|
if ( pge == NULL )
|
|
{
|
|
//
|
|
// group entry not found, quit
|
|
//
|
|
|
|
dwErr = ERROR_NOT_FOUND;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// acquire group entry lock and release group bucket lock
|
|
//
|
|
|
|
ACQUIRE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
bGrpEntryLock = TRUE;
|
|
|
|
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
bGrpLock = FALSE;
|
|
|
|
|
|
//
|
|
// Find Source entry
|
|
//
|
|
|
|
dwSrcBucket = SOURCE_TABLE_HASH( pmimm-> dwSource, pmimm-> dwSrcMask );
|
|
|
|
pleHead = SOURCE_BUCKET_HEAD( pge, dwSrcBucket );
|
|
|
|
pse = GetSourceEntry( pleHead, pmimm-> dwSource, pmimm-> dwSrcMask );
|
|
|
|
if ( pse == NULL )
|
|
{
|
|
//
|
|
// Source entry not found, quit
|
|
//
|
|
|
|
dwErr = ERROR_NOT_FOUND;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// check buffersize requirements
|
|
//
|
|
|
|
dwSizeReqd = ( dwFlags ) ?
|
|
( (dwFlags == MGM_MFE_STATS_0) ?
|
|
SIZEOF_MIB_MFE_STATS( pse-> dwMfeIfCount ) :
|
|
SIZEOF_MIB_MFE_STATS_EX(
|
|
pse-> dwMfeIfCount ) ) :
|
|
SIZEOF_MIB_MFE( pse-> dwMfeIfCount );
|
|
|
|
if ( *pdwBufferSize < dwSizeReqd )
|
|
{
|
|
//
|
|
// buffer supplied is too small to fit the MFE
|
|
//
|
|
|
|
*pdwBufferSize = dwSizeReqd;
|
|
|
|
dwErr = ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// if mfe statistics have been requested and
|
|
// mfe is in the kernel
|
|
// get it
|
|
//
|
|
|
|
if ( dwFlags && pse-> bInForwarder )
|
|
{
|
|
GetMfeFromForwarder( pge, pse );
|
|
}
|
|
|
|
#if 1
|
|
CopyMfe( pge, pse, pbBuffer, dwFlags );
|
|
#else
|
|
//
|
|
// copy base MFE into user supplied buffer
|
|
//
|
|
|
|
pmimms = ( PMIB_IPMCAST_MFE_STATS ) pbBuffer;
|
|
|
|
pmimms-> dwGroup = pge-> dwGroupAddr;
|
|
pmimms-> dwSource = pse-> dwSourceAddr;
|
|
pmimms-> dwSrcMask = pse-> dwSourceMask;
|
|
|
|
pmimms-> dwInIfIndex = pse-> dwInIfIndex;
|
|
pmimms-> dwUpStrmNgbr = pse-> dwUpstreamNeighbor;
|
|
pmimms-> dwInIfProtocol = pse-> dwInProtocolId;
|
|
|
|
pmimms-> dwRouteProtocol = pse-> dwRouteProtocol;
|
|
pmimms-> dwRouteNetwork = pse-> dwRouteNetwork;
|
|
pmimms-> dwRouteMask = pse-> dwRouteMask;
|
|
|
|
pmimms-> ulNumOutIf = pse-> imsStatistics.ulNumOutIf;
|
|
pmimms-> ulInPkts = pse-> imsStatistics.ulInPkts;
|
|
pmimms-> ulInOctets = pse-> imsStatistics.ulInOctets;
|
|
pmimms-> ulPktsDifferentIf = pse-> imsStatistics.ulPktsDifferentIf;
|
|
pmimms-> ulQueueOverflow = pse-> imsStatistics.ulQueueOverflow;
|
|
|
|
|
|
MgmElapsedSecs( &pse-> liCreationTime, &pmimms-> ulUpTime );
|
|
|
|
pmimms-> ulExpiryTime = pse-> dwTimeOut - pmimms-> ulUpTime;
|
|
|
|
|
|
//
|
|
// copy all the OIL entries
|
|
//
|
|
|
|
pleHead = &pse-> leMfeIfList;
|
|
|
|
for ( ple = pleHead-> Flink, dwInd = 0;
|
|
ple != pleHead;
|
|
ple = ple-> Flink, dwInd++ )
|
|
{
|
|
poie = CONTAINING_RECORD( ple, OUT_IF_ENTRY, leIfList );
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].dwOutIfIndex =
|
|
poie-> imosIfStats.dwOutIfIndex;
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].dwNextHopAddr =
|
|
poie-> imosIfStats.dwNextHopAddr;
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].ulTtlTooLow =
|
|
poie-> imosIfStats.ulTtlTooLow;
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].ulFragNeeded =
|
|
poie-> imosIfStats.ulFragNeeded;
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].ulOutPackets =
|
|
poie-> imosIfStats.ulOutPackets;
|
|
|
|
pmimms-> rgmiosOutStats[ dwInd ].ulOutDiscards =
|
|
poie-> imosIfStats.ulOutDiscards;
|
|
}
|
|
#endif
|
|
|
|
} while ( FALSE );
|
|
|
|
|
|
//
|
|
// release locks are appropriate
|
|
//
|
|
|
|
if ( bGrpEntryLock )
|
|
{
|
|
RELEASE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
}
|
|
|
|
if ( bGrpLock )
|
|
{
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
}
|
|
|
|
|
|
TRACEENUM1( ENUM, "LEAVING GetMfe :: %x", dwErr );
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// GetNextMfe
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
GetNextMfe(
|
|
IN PMIB_IPMCAST_MFE pmimmStart,
|
|
IN OUT PDWORD pdwBufferSize,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN OUT PDWORD pdwNumEntries,
|
|
IN BOOL bIncludeFirst,
|
|
IN DWORD dwFlags
|
|
)
|
|
{
|
|
|
|
BOOL bFound, bgeLock = FALSE;
|
|
|
|
DWORD dwGrpBucket, dwErr = NO_ERROR, dwBufferLeft,
|
|
dwStartSource, dwSize;
|
|
|
|
PBYTE pbStart;
|
|
|
|
PGROUP_ENTRY pge;
|
|
|
|
PLIST_ENTRY ple, pleMasterHead, pleGrpBucket;
|
|
|
|
|
|
|
|
TRACEENUM2(
|
|
ENUM, "ENTERED GetNextMfe (G, S) = (%x, %x)", pmimmStart-> dwGroup,
|
|
pmimmStart-> dwSource
|
|
);
|
|
|
|
|
|
do
|
|
{
|
|
//
|
|
// 1. Lock group hash bucket.
|
|
//
|
|
|
|
dwGrpBucket = GROUP_TABLE_HASH( pmimmStart-> dwGroup, 0 );
|
|
|
|
ACQUIRE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
|
|
//
|
|
// 2. merge temp and master lists
|
|
// - Lock temp list
|
|
// - merge temp with master list
|
|
// - unlock temp list
|
|
//
|
|
|
|
ACQUIRE_TEMP_GROUP_LOCK_EXCLUSIVE();
|
|
|
|
MergeTempAndMasterGroupLists( TEMP_GROUP_LIST_HEAD() );
|
|
|
|
ACQUIRE_MASTER_GROUP_LOCK_SHARED();
|
|
|
|
RELEASE_TEMP_GROUP_LOCK_EXCLUSIVE();
|
|
|
|
|
|
pleMasterHead = MASTER_GROUP_LIST_HEAD();
|
|
|
|
ple = pleMasterHead-> Flink;
|
|
|
|
//
|
|
// To retrieve the next set of group entries in lexicographic order,
|
|
// given a group entry (in this case specified by pmimmStart-> dwGroup)
|
|
// the master group list must be walked from the head until either
|
|
// the group entry specified is found or the next "higher" group entry
|
|
// is found. This is expensive.
|
|
//
|
|
// As an optimization the group specified (pmimmStart-> dwGroup) is
|
|
// looked up in the group hash table. If an entry is found, then the
|
|
// group entry contains links into the master (lexicographic) group
|
|
// list. These links can the used to determine the next entries in
|
|
// the group list. This way we can quickly find an group entry in
|
|
// the master list rather than walk the master group list from the
|
|
// beginning.
|
|
//
|
|
// It should be noted that in case the group entry specified in not
|
|
// present in the group hash table, it will be necessary to walk the
|
|
// master group list from the start.
|
|
//
|
|
// Each group entry is present in two lists, the hash bucket list
|
|
// and either temp group list or the master group list.
|
|
//
|
|
// For this optimization to "work", it must be ensured that an entry
|
|
// present in the hash table is also present in the master
|
|
// group list. To ensure this the temp group list is merged into
|
|
// the master group list before searching the group hash table for
|
|
// the specified entry.
|
|
//
|
|
|
|
|
|
//
|
|
// At this point the group under consideration (pmimmStart-> dwGroup),
|
|
// cannot be added to either the hash bucket or master group list
|
|
// if it is not already present because both the group hash bucket lock
|
|
// and the master list lock have been acquired.
|
|
//
|
|
|
|
//
|
|
// 3. find group entry in the hash list
|
|
//
|
|
|
|
pleGrpBucket = GROUP_BUCKET_HEAD( dwGrpBucket );
|
|
|
|
pge = GetGroupEntry( pleGrpBucket, pmimmStart-> dwGroup, 0 );
|
|
|
|
if ( pge != NULL )
|
|
{
|
|
//
|
|
// group entry for pmimmStart-> dwGroup is present. lock the entry.
|
|
//
|
|
|
|
ACQUIRE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
bgeLock = TRUE;
|
|
|
|
//
|
|
// release group hash bucket lock
|
|
//
|
|
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
}
|
|
|
|
else
|
|
{
|
|
|
|
//
|
|
// group entry is not present in the hash table, which implies
|
|
// that the group entry is not present at all.
|
|
//
|
|
|
|
//
|
|
// release group hash bucket lock
|
|
//
|
|
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
//
|
|
// 3.1 Walk master list from the start to determine the next
|
|
// highest group entry.
|
|
//
|
|
|
|
bFound = FindGroupEntry(
|
|
pleMasterHead, pmimmStart-> dwGroup, 0,
|
|
&pge, FALSE
|
|
);
|
|
|
|
if ( !bFound && pge == NULL )
|
|
{
|
|
//
|
|
// No more group entries left to enumerate
|
|
//
|
|
|
|
dwErr = ERROR_NO_MORE_ITEMS;
|
|
|
|
RELEASE_MASTER_GROUP_LOCK_SHARED();
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Next group entry found. lock it
|
|
//
|
|
|
|
ACQUIRE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
bgeLock = TRUE;
|
|
|
|
bIncludeFirst = TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// At this point we have the group entry we want which is
|
|
// either the one for pmimmStart-> dwGroup OR the next higher
|
|
// one (if there is no group entry for pmimmStart-> Group).
|
|
//
|
|
|
|
//
|
|
// 4. Now get as many source entries as will fit into
|
|
// the buffer provided.
|
|
//
|
|
|
|
dwBufferLeft = *pdwBufferSize;
|
|
|
|
pbStart = pbBuffer;
|
|
|
|
*pdwNumEntries = 0;
|
|
|
|
dwStartSource = ( bIncludeFirst ) ? 0 : pmimmStart-> dwSource;
|
|
|
|
dwSize = 0;
|
|
|
|
|
|
while ( ( dwErr = GetGroupMfes( pge, dwStartSource, pbStart,
|
|
dwBufferLeft, &dwSize, pdwNumEntries,
|
|
bIncludeFirst, dwFlags ) )
|
|
== ERROR_MORE_DATA )
|
|
{
|
|
//
|
|
// more data items will fit into this buffer, but no more
|
|
// source entries available in this group entry
|
|
//
|
|
// 4.1 Move forward to next group entry.
|
|
//
|
|
|
|
pbStart += dwSize;
|
|
|
|
dwBufferLeft -= dwSize;
|
|
|
|
dwSize = 0;
|
|
|
|
dwStartSource = 0;
|
|
|
|
|
|
//
|
|
// 4.1.1 Release this group entry lock
|
|
//
|
|
|
|
RELEASE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
|
|
|
|
//
|
|
// 4.1.2 get next entry lock
|
|
//
|
|
|
|
ple = pge-> leGrpList.Flink;
|
|
|
|
if ( ple == pleMasterHead )
|
|
{
|
|
//
|
|
// No more group entries in the master group list.
|
|
// All MFEs have been exhausted. So quit.
|
|
//
|
|
|
|
dwErr = ERROR_NO_MORE_ITEMS;
|
|
|
|
bgeLock = FALSE;
|
|
|
|
break;
|
|
}
|
|
|
|
pge = CONTAINING_RECORD( ple, GROUP_ENTRY, leGrpList );
|
|
|
|
ACQUIRE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
|
|
dwStartSource = 0;
|
|
|
|
bIncludeFirst = TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// 5. you have packed as much as possible into the buffer
|
|
//
|
|
// Clean up and return the correct error code.
|
|
//
|
|
|
|
if ( bgeLock )
|
|
{
|
|
RELEASE_GROUP_ENTRY_LOCK_EXCLUSIVE( pge );
|
|
}
|
|
|
|
|
|
if ( dwErr == ERROR_INSUFFICIENT_BUFFER )
|
|
{
|
|
//
|
|
// ran out of buffer. If there is at least one Mfe
|
|
// packed into the buffer provided then it is ok.
|
|
//
|
|
|
|
if ( *pdwNumEntries != 0 )
|
|
{
|
|
dwErr = ERROR_MORE_DATA;
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// not even one entry could be packed into the buffer
|
|
// return the size required for this so that an
|
|
// appropriately sized buffer can be allocated for the
|
|
// next call.
|
|
//
|
|
|
|
*pdwBufferSize = dwSize;
|
|
}
|
|
}
|
|
|
|
RELEASE_MASTER_GROUP_LOCK_SHARED();
|
|
|
|
} while ( FALSE );
|
|
|
|
|
|
TRACEENUM1( ENUM, "LEAVING GetNextMfe : %x", dwErr );
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// GetGroupMfes
|
|
//
|
|
// Retrieves as many MFEs for a group starting at the specified source.
|
|
// Assumes that the group entry is locked.
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
GetGroupMfes(
|
|
IN PGROUP_ENTRY pge,
|
|
IN DWORD dwStartSource,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN DWORD dwBufferSize,
|
|
IN OUT PDWORD pdwSize,
|
|
IN OUT PDWORD pdwNumEntries,
|
|
IN BOOL bIncludeFirst,
|
|
IN DWORD dwFlags
|
|
)
|
|
{
|
|
|
|
BOOL bFound;
|
|
|
|
DWORD dwErr = ERROR_MORE_DATA, dwSrcBucket,
|
|
dwSizeReqd, dwInd;
|
|
|
|
PSOURCE_ENTRY pse = NULL;
|
|
|
|
PLIST_ENTRY pleMasterHead, pleSrcBucket, ple = NULL,
|
|
pleSrc;
|
|
|
|
POUT_IF_ENTRY poie = NULL;
|
|
|
|
|
|
TRACEENUM2(
|
|
ENUM, "ENTERED GetGroupMfes : %x, %x",
|
|
pge-> dwGroupAddr, dwStartSource
|
|
);
|
|
|
|
do
|
|
{
|
|
//
|
|
// merge temp and group source lists
|
|
//
|
|
|
|
MergeTempAndMasterSourceLists( pge );
|
|
|
|
|
|
//
|
|
// similar to the group lookup, optimize the source lookup
|
|
// by first trying to find the source entry in the source
|
|
// hash table.
|
|
//
|
|
// If found in the hash table then use the entry's links
|
|
// the into master source list to find next entry.
|
|
//
|
|
// if not found in the hash table walk the master list from
|
|
// the beginning to determine the next entry.
|
|
//
|
|
|
|
pleMasterHead = MASTER_SOURCE_LIST_HEAD( pge );
|
|
|
|
dwSrcBucket = SOURCE_TABLE_HASH( dwStartSource, 0 );
|
|
|
|
pleSrcBucket = SOURCE_BUCKET_HEAD( pge, dwSrcBucket );
|
|
|
|
|
|
bFound = FindSourceEntry( pleSrcBucket, dwStartSource, 0, &pse, TRUE );
|
|
|
|
if ( !bFound )
|
|
{
|
|
//
|
|
// source entry is not present in the hash table
|
|
// Walk the master source list from the start.
|
|
//
|
|
|
|
pse = NULL;
|
|
|
|
FindSourceEntry( pleMasterHead, 0, 0, &pse, FALSE );
|
|
|
|
|
|
//
|
|
// No next entry found in the master list. Implies
|
|
// no more sources in the master source list for this group.
|
|
//
|
|
|
|
if ( pse == NULL )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// Entry for starting source found in hash table.
|
|
// Use its links into the master list to get next entry.
|
|
//
|
|
|
|
if ( !bIncludeFirst )
|
|
{
|
|
ple = pse-> leSrcList.Flink;
|
|
|
|
pse = CONTAINING_RECORD( ple, SOURCE_ENTRY, leSrcList );
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// At this point the entry pointed to by pse is the first entry
|
|
// the needs to be packed into the buffer supplied. Starting
|
|
// with this source entry keep packing MFEs into the
|
|
// buffer till there are no more MFEs for this group.
|
|
//
|
|
|
|
pleSrc = &pse-> leSrcList;
|
|
|
|
//
|
|
// while there are source entries for this group entry
|
|
//
|
|
|
|
while ( pleSrc != pleMasterHead )
|
|
{
|
|
pse = CONTAINING_RECORD( pleSrc, SOURCE_ENTRY, leSrcList );
|
|
|
|
|
|
//
|
|
// Is this source entry an MFE
|
|
//
|
|
|
|
if ( !IS_VALID_INTERFACE( pse-> dwInIfIndex,
|
|
pse-> dwInIfNextHopAddr ) )
|
|
{
|
|
pleSrc = pleSrc-> Flink;
|
|
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// This source entry is an MFE also.
|
|
//
|
|
|
|
//
|
|
// Check if enough space left in the buffer to fit this MFE.
|
|
//
|
|
// If not and not a single MFE is present in the buffer then
|
|
// return the size required to fit this MFE.
|
|
//
|
|
|
|
dwSizeReqd = ( dwFlags ) ?
|
|
( ( dwFlags == MGM_MFE_STATS_0 ) ?
|
|
SIZEOF_MIB_MFE_STATS( pse-> dwMfeIfCount ) :
|
|
SIZEOF_MIB_MFE_STATS_EX(
|
|
pse-> dwMfeIfCount
|
|
) ) :
|
|
SIZEOF_MIB_MFE( pse-> dwMfeIfCount );
|
|
|
|
if ( dwBufferSize < dwSizeReqd )
|
|
{
|
|
dwErr = ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
if ( *pdwNumEntries == 0 )
|
|
{
|
|
*pdwSize = dwSizeReqd;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// If MFE stats have been requested and
|
|
// MFE is present in the forwarder
|
|
// get them.
|
|
//
|
|
|
|
if ( dwFlags && pse-> bInForwarder )
|
|
{
|
|
//
|
|
// MFE is currently in the forwarder. Query it and update
|
|
// stats user mode.
|
|
//
|
|
|
|
GetMfeFromForwarder( pge, pse );
|
|
}
|
|
|
|
|
|
//
|
|
// copy base MFE into user supplied buffer
|
|
//
|
|
|
|
|
|
CopyMfe( pge, pse, pbBuffer, dwFlags );
|
|
|
|
pbBuffer += dwSizeReqd;
|
|
|
|
dwBufferSize -= dwSizeReqd;
|
|
|
|
*pdwSize += dwSizeReqd;
|
|
|
|
(*pdwNumEntries)++;
|
|
|
|
pleSrc = pleSrc-> Flink;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
|
|
TRACEENUM2( ENUM, "LEAVING GetGroupsMfes : %d %d", *pdwNumEntries, dwErr );
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
//============================================================================
|
|
// Group Enumeration
|
|
//
|
|
//============================================================================
|
|
|
|
|
|
PGROUP_ENUMERATOR
|
|
VerifyEnumeratorHandle(
|
|
IN HANDLE hEnum
|
|
)
|
|
{
|
|
|
|
DWORD dwErr;
|
|
|
|
PGROUP_ENUMERATOR pgeEnum;
|
|
|
|
|
|
|
|
pgeEnum = (PGROUP_ENUMERATOR)
|
|
( ( (ULONG_PTR) hEnum )
|
|
^ (ULONG_PTR) MGM_ENUM_HANDLE_TAG );
|
|
|
|
try
|
|
{
|
|
if ( pgeEnum-> dwSignature != MGM_ENUM_SIGNATURE )
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
|
|
TRACE0( ANY, "Invalid Enumeration handle" );
|
|
|
|
pgeEnum = NULL;
|
|
}
|
|
}
|
|
|
|
except ( GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
|
|
EXCEPTION_EXECUTE_HANDLER :
|
|
EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
|
|
TRACE0( ANY, "Invalid enumeration handle" );
|
|
|
|
pgeEnum = NULL;
|
|
}
|
|
|
|
return pgeEnum;
|
|
}
|
|
|
|
|
|
//
|
|
// Get Memberships for buckets
|
|
//
|
|
|
|
DWORD
|
|
GetNextGroupMemberships(
|
|
IN PGROUP_ENUMERATOR pgeEnum,
|
|
IN OUT PDWORD pdwBufferSize,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN OUT PDWORD pdwNumEntries
|
|
)
|
|
{
|
|
|
|
BOOL bIncludeFirst = TRUE, bFound;
|
|
|
|
DWORD dwMaxEntries, dwGrpBucket, dwErr = ERROR_NO_MORE_ITEMS;
|
|
|
|
PGROUP_ENTRY pge = NULL;
|
|
|
|
PSOURCE_GROUP_ENTRY psge;
|
|
|
|
PLIST_ENTRY ple, pleGrpHead;
|
|
|
|
|
|
|
|
do
|
|
{
|
|
//
|
|
// Compute the number of entries that will fit into the buffer
|
|
//
|
|
|
|
dwMaxEntries = (*pdwBufferSize) / sizeof( SOURCE_GROUP_ENTRY );
|
|
|
|
|
|
//
|
|
// STEP I :
|
|
//
|
|
|
|
//
|
|
// position the start of the GetNext to the group entry that was
|
|
// the last enumerated by the previous GetNext operation
|
|
//
|
|
|
|
//
|
|
// Find the last group entry retrieved by the previous get operation.
|
|
//
|
|
|
|
dwGrpBucket = GROUP_TABLE_HASH(
|
|
pgeEnum-> dwLastGroup, pgeEnum-> dwLastGroupMask
|
|
);
|
|
|
|
ACQUIRE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
pleGrpHead = GROUP_BUCKET_HEAD( dwGrpBucket );
|
|
|
|
bFound = FindGroupEntry(
|
|
pleGrpHead, pgeEnum-> dwLastGroup,
|
|
pgeEnum-> dwLastGroupMask, &pge, TRUE
|
|
);
|
|
|
|
if ( bFound )
|
|
{
|
|
//
|
|
// group entry found
|
|
//
|
|
|
|
bIncludeFirst = !pgeEnum-> bEnumBegun;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// last group entry retrieved by previous getnext is no
|
|
// longer present
|
|
//
|
|
|
|
//
|
|
// check if there are any more group entries present in
|
|
// the same bucket
|
|
//
|
|
|
|
else if ( pge != NULL )
|
|
{
|
|
//
|
|
// Next group entry in the same group bucket.
|
|
// For a new group start from the first source bucket,
|
|
// first source entry.
|
|
//
|
|
|
|
pgeEnum-> dwLastSource = 0;
|
|
pgeEnum-> dwLastSourceMask = 0;
|
|
}
|
|
|
|
|
|
else // ( pge == NULL )
|
|
{
|
|
//
|
|
// no more entries in this group bucket, move to next
|
|
// non-empty group bucket entry.
|
|
//
|
|
|
|
//
|
|
// skip empty buckets in the group hash table
|
|
//
|
|
|
|
do
|
|
{
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
dwGrpBucket++;
|
|
|
|
if ( dwGrpBucket >= GROUP_TABLE_SIZE )
|
|
{
|
|
//
|
|
// Entire hash table has been traversed, quit
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Move to next group bucket
|
|
//
|
|
|
|
ACQUIRE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
pleGrpHead = GROUP_BUCKET_HEAD( dwGrpBucket );
|
|
|
|
|
|
//
|
|
// Check if any group entries present
|
|
//
|
|
|
|
if ( !IsListEmpty( pleGrpHead ) )
|
|
{
|
|
//
|
|
// group bucket has at least on group entry
|
|
//
|
|
|
|
pge = CONTAINING_RECORD(
|
|
pleGrpHead-> Flink, GROUP_ENTRY, leGrpHashList
|
|
);
|
|
|
|
//
|
|
// For a new group start from the first source bucket,
|
|
// first source entry.
|
|
//
|
|
|
|
pgeEnum-> dwLastSource = 0;
|
|
pgeEnum-> dwLastSourceMask = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Empty group bucket, move to next one
|
|
//
|
|
|
|
} while ( TRUE );
|
|
}
|
|
|
|
|
|
//
|
|
// if all hash buckets have been traversed, quit.
|
|
//
|
|
|
|
if ( dwGrpBucket >= GROUP_TABLE_SIZE )
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// STEP II:
|
|
//
|
|
|
|
//
|
|
// start retrieving group membership entries
|
|
//
|
|
|
|
#pragma prefast(suppress: 11, pge will be initialized else we would broken out above (PREFast bug 758))
|
|
ple = &pge-> leGrpHashList;
|
|
|
|
|
|
//
|
|
// Walk each hash bucket starting from dwGrpBucket to GROUP_TABLE_SIZE
|
|
//
|
|
|
|
while ( dwGrpBucket < GROUP_TABLE_SIZE )
|
|
{
|
|
//
|
|
// For each group hash table bucket
|
|
//
|
|
|
|
while ( ple != pleGrpHead )
|
|
{
|
|
//
|
|
// For each group entry in the bucket
|
|
//
|
|
|
|
pge = CONTAINING_RECORD( ple, GROUP_ENTRY, leGrpHashList );
|
|
|
|
ACQUIRE_GROUP_ENTRY_LOCK_SHARED( pge );
|
|
|
|
dwErr = GetNextMembershipsForThisGroup(
|
|
pge, pgeEnum, bIncludeFirst, pbBuffer,
|
|
pdwNumEntries, dwMaxEntries
|
|
);
|
|
|
|
RELEASE_GROUP_ENTRY_LOCK_SHARED( pge );
|
|
|
|
if ( dwErr == ERROR_MORE_DATA )
|
|
{
|
|
//
|
|
// User supplied buffer is full.
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Move to next entry
|
|
//
|
|
|
|
ple = ple-> Flink;
|
|
|
|
//
|
|
// Next group entry in the same group bucket.
|
|
// For a new group start from the first source bucket,
|
|
// first source entry.
|
|
//
|
|
|
|
pgeEnum-> dwLastSource = 0;
|
|
|
|
pgeEnum-> dwLastSourceMask = 0;
|
|
|
|
bIncludeFirst = TRUE;
|
|
}
|
|
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
if ( dwErr == ERROR_MORE_DATA )
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Move to next group bucket
|
|
//
|
|
|
|
dwGrpBucket++;
|
|
|
|
//
|
|
// skip empty group hash buckets
|
|
//
|
|
|
|
while ( dwGrpBucket < GROUP_TABLE_SIZE )
|
|
{
|
|
ACQUIRE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
pleGrpHead = GROUP_BUCKET_HEAD( dwGrpBucket );
|
|
|
|
if ( !IsListEmpty( pleGrpHead ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
RELEASE_GROUP_LOCK_SHARED( dwGrpBucket );
|
|
|
|
dwGrpBucket++;
|
|
}
|
|
|
|
|
|
if ( dwGrpBucket >= GROUP_TABLE_SIZE )
|
|
{
|
|
//
|
|
// All group buckets have traversed. End of enumeration
|
|
//
|
|
|
|
dwErr = ERROR_NO_MORE_ITEMS;
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// New group hash bucket, start from source entry 0.
|
|
//
|
|
|
|
ple = pleGrpHead-> Flink;
|
|
|
|
pgeEnum-> dwLastSource = 0;
|
|
pgeEnum-> dwLastSourceMask = 0;
|
|
bIncludeFirst = TRUE;
|
|
}
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
pgeEnum-> bEnumBegun = TRUE;
|
|
|
|
|
|
//
|
|
// Store the position where the enumeration ended
|
|
//
|
|
|
|
psge = (PSOURCE_GROUP_ENTRY) pbBuffer;
|
|
|
|
if ( *pdwNumEntries )
|
|
{
|
|
pgeEnum-> dwLastSource = psge[ *pdwNumEntries - 1 ].dwSourceAddr;
|
|
|
|
pgeEnum-> dwLastSourceMask = psge[ *pdwNumEntries - 1 ].dwSourceMask;
|
|
|
|
pgeEnum-> dwLastGroup = psge[ *pdwNumEntries - 1 ].dwGroupAddr;
|
|
|
|
pgeEnum-> dwLastGroupMask = psge[ *pdwNumEntries - 1 ].dwGroupMask;
|
|
}
|
|
|
|
else
|
|
{
|
|
pgeEnum-> dwLastSource = 0xFFFFFFFF;
|
|
|
|
pgeEnum-> dwLastSourceMask = 0xFFFFFFFF;
|
|
|
|
pgeEnum-> dwLastGroup = 0xFFFFFFFF;
|
|
|
|
pgeEnum-> dwLastGroupMask = 0xFFFFFFFF;
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// GetMemberships for Group
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
GetNextMembershipsForThisGroup(
|
|
IN PGROUP_ENTRY pge,
|
|
IN OUT PGROUP_ENUMERATOR pgeEnum,
|
|
IN BOOL bIncludeFirst,
|
|
IN OUT PBYTE pbBuffer,
|
|
IN OUT PDWORD pdwNumEntries,
|
|
IN DWORD dwMaxEntries
|
|
)
|
|
{
|
|
|
|
BOOL bFound;
|
|
|
|
DWORD dwErr = ERROR_NO_MORE_ITEMS, dwSrcBucket;
|
|
|
|
PSOURCE_GROUP_ENTRY psgBuffer;
|
|
|
|
PSOURCE_ENTRY pse = NULL;
|
|
|
|
PLIST_ENTRY pleSrcHead, ple;
|
|
|
|
|
|
|
|
do
|
|
{
|
|
|
|
if ( *pdwNumEntries >= dwMaxEntries )
|
|
{
|
|
//
|
|
// quit here.
|
|
//
|
|
|
|
dwErr = ERROR_MORE_DATA;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
psgBuffer = (PSOURCE_GROUP_ENTRY) pbBuffer;
|
|
|
|
|
|
//
|
|
// STEP I:
|
|
// Position start of enumeration
|
|
//
|
|
|
|
dwSrcBucket = SOURCE_TABLE_HASH(
|
|
pgeEnum-> dwLastSource, pgeEnum-> dwLastSourceMask
|
|
);
|
|
|
|
pleSrcHead = SOURCE_BUCKET_HEAD( pge, dwSrcBucket );
|
|
|
|
bFound = FindSourceEntry(
|
|
pleSrcHead, pgeEnum-> dwLastSource,
|
|
pgeEnum-> dwLastSourceMask, &pse, TRUE
|
|
);
|
|
|
|
if ( bFound )
|
|
{
|
|
if ( ( bIncludeFirst ) && !IsListEmpty( &pse-> leOutIfList ) )
|
|
{
|
|
//
|
|
// the first group membership found.
|
|
//
|
|
|
|
psgBuffer[ *pdwNumEntries ].dwSourceAddr = pse-> dwSourceAddr;
|
|
|
|
psgBuffer[ *pdwNumEntries ].dwSourceMask = pse-> dwSourceMask;
|
|
|
|
psgBuffer[ *pdwNumEntries ].dwGroupAddr = pge-> dwGroupAddr;
|
|
|
|
psgBuffer[ (*pdwNumEntries)++ ].dwGroupMask = pge-> dwGroupMask;
|
|
|
|
if ( *pdwNumEntries >= dwMaxEntries )
|
|
{
|
|
//
|
|
// buffer full. quit here.
|
|
//
|
|
|
|
dwErr = ERROR_MORE_DATA;
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// move to next source
|
|
//
|
|
|
|
ple = pse-> leSrcHashList.Flink;
|
|
}
|
|
|
|
else
|
|
{
|
|
ple = pse-> leSrcHashList.Flink;
|
|
}
|
|
}
|
|
|
|
else if ( pse != NULL )
|
|
{
|
|
ple = &pse-> leSrcHashList;
|
|
}
|
|
|
|
else
|
|
{
|
|
ple = pleSrcHead-> Flink;
|
|
}
|
|
|
|
|
|
//
|
|
// STEP II:
|
|
//
|
|
// enumerate group memberships
|
|
//
|
|
|
|
while ( *pdwNumEntries < dwMaxEntries )
|
|
{
|
|
//
|
|
// for each source bucket
|
|
//
|
|
|
|
while ( ( ple != pleSrcHead ) &&
|
|
( *pdwNumEntries < dwMaxEntries ) )
|
|
{
|
|
//
|
|
// for each source entry in the bucket
|
|
//
|
|
|
|
//
|
|
// if group membership exists for this source
|
|
//
|
|
|
|
pse = CONTAINING_RECORD( ple, SOURCE_ENTRY, leSrcHashList );
|
|
|
|
if ( !IsListEmpty( &pse-> leOutIfList ) )
|
|
{
|
|
psgBuffer[ *pdwNumEntries ].dwSourceAddr =
|
|
pse-> dwSourceAddr;
|
|
|
|
psgBuffer[ *pdwNumEntries ].dwSourceMask =
|
|
pse-> dwSourceMask;
|
|
|
|
psgBuffer[ *pdwNumEntries ].dwGroupAddr =
|
|
pge-> dwGroupAddr;
|
|
|
|
psgBuffer[ (*pdwNumEntries)++ ].dwGroupMask =
|
|
pge-> dwGroupMask;
|
|
|
|
if ( *pdwNumEntries >= dwMaxEntries )
|
|
{
|
|
dwErr = ERROR_MORE_DATA;
|
|
}
|
|
}
|
|
|
|
ple = ple-> Flink;
|
|
}
|
|
|
|
dwSrcBucket++;
|
|
|
|
if ( dwSrcBucket < SOURCE_TABLE_SIZE )
|
|
{
|
|
pleSrcHead = SOURCE_BUCKET_HEAD( pge, dwSrcBucket );
|
|
|
|
ple = pleSrcHead-> Flink;
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// all source buckets for this group have been
|
|
// traversed. quit this group entry
|
|
//
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Copy the MFE (optionally with stats)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
VOID
|
|
CopyMfe(
|
|
IN PGROUP_ENTRY pge,
|
|
IN PSOURCE_ENTRY pse,
|
|
IN OUT PBYTE pb,
|
|
IN DWORD dwFlags
|
|
)
|
|
{
|
|
DWORD dwInd;
|
|
|
|
PLIST_ENTRY ple, pleHead;
|
|
|
|
POUT_IF_ENTRY poie;
|
|
|
|
PMIB_IPMCAST_MFE pmimm = NULL;
|
|
|
|
PMIB_IPMCAST_MFE_STATS pmimms = NULL;
|
|
|
|
PMIB_IPMCAST_OIF_STATS pmimos = NULL;
|
|
|
|
//
|
|
// copy base MFE into user supplied buffer
|
|
//
|
|
|
|
if ( dwFlags )
|
|
{
|
|
//
|
|
// Need to base MFE
|
|
//
|
|
|
|
pmimms = ( PMIB_IPMCAST_MFE_STATS ) pb;
|
|
|
|
pmimms-> dwGroup = pge-> dwGroupAddr;
|
|
pmimms-> dwSource = pse-> dwSourceAddr;
|
|
pmimms-> dwSrcMask = pse-> dwSourceMask;
|
|
|
|
pmimms-> dwInIfIndex = pse-> dwInIfIndex;
|
|
pmimms-> dwUpStrmNgbr = pse-> dwUpstreamNeighbor;
|
|
pmimms-> dwInIfProtocol = pse-> dwInProtocolId;
|
|
|
|
pmimms-> dwRouteProtocol = pse-> dwRouteProtocol;
|
|
pmimms-> dwRouteNetwork = pse-> dwRouteNetwork;
|
|
pmimms-> dwRouteMask = pse-> dwRouteMask;
|
|
|
|
MgmElapsedSecs( &pse-> liCreationTime, &pmimms-> ulUpTime );
|
|
|
|
pmimms-> ulExpiryTime = pse-> dwTimeOut - pmimms-> ulUpTime;
|
|
|
|
|
|
//
|
|
// Copy incoming stats
|
|
//
|
|
|
|
pmimms-> ulNumOutIf = pse-> dwMfeIfCount;
|
|
pmimms-> ulInPkts = pse-> imsStatistics.ulInPkts;
|
|
pmimms-> ulInOctets = pse-> imsStatistics.ulInOctets;
|
|
pmimms-> ulPktsDifferentIf = pse-> imsStatistics.ulPktsDifferentIf;
|
|
pmimms-> ulQueueOverflow = pse-> imsStatistics.ulQueueOverflow;
|
|
|
|
if ( dwFlags & MGM_MFE_STATS_1 )
|
|
{
|
|
PMIB_IPMCAST_MFE_STATS_EX pmimmsex =
|
|
( PMIB_IPMCAST_MFE_STATS_EX ) pb;
|
|
|
|
pmimmsex-> ulUninitMfe = pse-> imsStatistics.ulUninitMfe;
|
|
pmimmsex-> ulNegativeMfe = pse-> imsStatistics.ulNegativeMfe;
|
|
pmimmsex-> ulInDiscards = pse-> imsStatistics.ulInDiscards;
|
|
pmimmsex-> ulInHdrErrors = pse-> imsStatistics.ulInHdrErrors;
|
|
pmimmsex-> ulTotalOutPackets= pse-> imsStatistics.ulTotalOutPackets;
|
|
|
|
pmimos = pmimmsex-> rgmiosOutStats;
|
|
}
|
|
|
|
else
|
|
{
|
|
pmimos = pmimms-> rgmiosOutStats;
|
|
}
|
|
|
|
//
|
|
// copy all the OIL entries
|
|
//
|
|
|
|
pleHead = &pse-> leMfeIfList;
|
|
|
|
for ( ple = pleHead-> Flink, dwInd = 0;
|
|
ple != pleHead;
|
|
ple = ple-> Flink, dwInd++ )
|
|
{
|
|
poie = CONTAINING_RECORD( ple, OUT_IF_ENTRY, leIfList );
|
|
|
|
pmimos[ dwInd ].dwOutIfIndex = poie-> dwIfIndex;
|
|
pmimos[ dwInd ].dwNextHopAddr = poie-> dwIfNextHopAddr;
|
|
|
|
//
|
|
// Copy outgoing stats
|
|
//
|
|
|
|
pmimos[ dwInd ].ulTtlTooLow = poie-> imosIfStats.ulTtlTooLow;
|
|
pmimos[ dwInd ].ulFragNeeded = poie-> imosIfStats.ulFragNeeded;
|
|
pmimos[ dwInd ].ulOutPackets = poie-> imosIfStats.ulOutPackets;
|
|
pmimos[ dwInd ].ulOutDiscards = poie-> imosIfStats.ulOutDiscards;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// Need to copy non-stats MFE structure only
|
|
//
|
|
|
|
pmimm = (PMIB_IPMCAST_MFE) pb;
|
|
|
|
pmimm-> dwGroup = pge-> dwGroupAddr;
|
|
pmimm-> dwSource = pse-> dwSourceAddr;
|
|
pmimm-> dwSrcMask = pse-> dwSourceMask;
|
|
|
|
pmimm-> dwInIfIndex = pse-> dwInIfIndex;
|
|
pmimm-> dwUpStrmNgbr = pse-> dwUpstreamNeighbor;
|
|
pmimm-> dwInIfProtocol = pse-> dwInProtocolId;
|
|
|
|
pmimm-> dwRouteProtocol = pse-> dwRouteProtocol;
|
|
pmimm-> dwRouteNetwork = pse-> dwRouteNetwork;
|
|
pmimm-> dwRouteMask = pse-> dwRouteMask;
|
|
|
|
pmimm-> ulNumOutIf = pse-> dwMfeIfCount;
|
|
|
|
MgmElapsedSecs( &pse-> liCreationTime, &pmimm-> ulUpTime );
|
|
|
|
pmimm-> ulExpiryTime = pse-> dwTimeOut - pmimm-> ulUpTime;
|
|
|
|
|
|
//
|
|
// copy all the OIL entries minus the stats
|
|
//
|
|
|
|
pleHead = &pse-> leMfeIfList;
|
|
|
|
for ( ple = pleHead-> Flink, dwInd = 0;
|
|
ple != pleHead;
|
|
ple = ple-> Flink, dwInd++ )
|
|
{
|
|
poie = CONTAINING_RECORD( ple, OUT_IF_ENTRY, leIfList );
|
|
|
|
pmimm-> rgmioOutInfo[ dwInd ].dwOutIfIndex =
|
|
poie-> dwIfIndex;
|
|
|
|
pmimm-> rgmioOutInfo[ dwInd ].dwNextHopAddr =
|
|
poie-> dwIfNextHopAddr;
|
|
}
|
|
}
|
|
}
|