lspmap.cpp File Reference

#include "instlsp.h"

Include dependency graph for lspmap.cpp:

Go to the source code of this file.

Functions
void	PrintProviders (WINSOCK_CATALOG Catalog, BOOL bLayeredOnly, BOOL bVerbose)
LSP_ENTRY *	BuildLspMap (WSAPROTOCOL_INFOW *pProviders, int iProviderCount, int *pLspCount)
void	PrintLspMap (LSP_ENTRY *pLspMap, int iLspCount)
void	FreeLspMap (LSP_ENTRY *pLspMap, int iLspCount)
int	LspDependencyCheck (LSP_ENTRY *pLspMap, int iLspCount)
void	UpdateLspMap (LSP_ENTRY *pLspMap, DWORD dwOldValue, DWORD dwNewValue)
void	MapNewEntriesToOld (LSP_ENTRY *pEntry, WSAPROTOCOL_INFOW *pProvider, int iProviderCount)
int	AddGuidToLspEntry (LSP_ENTRY *entry, GUID *guid, int *lpErrno)
void	UpdateProviderOrder (LSP_ENTRY *UpdatedEntry, DWORD *OrderArray, int ArrayCount)
int	MaxLayeredChainCount (LSP_ENTRY *pLspMap, int LspCount)

---

Function Documentation

int AddGuidToLspEntry	(	LSP_ENTRY *	entry,
		GUID *	guid,
		int *	lpErrno
	)

Definition at line 853 of file lspmap.cpp.

{
    BOOL    bFound;
    int     rc,
            i;

    if ( 0 == entry->Count )
    {
        entry->LayeredGuids = (GUID *) LspAlloc(
                sizeof( GUID ),
                lpErrno 
                );
        if ( NULL == entry->LayeredGuids )
        {
            fprintf( stderr, "AddGuidToLspEntry: LspAlloc failed: %d\n", *lpErrno );
            goto cleanup;
        }

        memcpy( &entry->LayeredGuids[ 0 ], guid, sizeof( GUID ) );

        entry->LayeredGuidCount++;
    }
    else
    {
        // See if we've already seen this guid
        bFound = FALSE;
        for(i=0; i < entry->LayeredGuidCount ;i++)
        {
            rc = memcmp( &entry->LayeredGuids[ i ], guid, sizeof( GUID ) );
            if ( 0 == rc )
            {
                bFound = TRUE;
                break;
            }
        }
        if ( FALSE == bFound )
        {
            GUID    *tmpguid = NULL;

            // New GUID -- we need to add it to the array
            tmpguid = (GUID *) LspAlloc(
                    sizeof( GUID ) * ( entry->LayeredGuidCount + 1 ),
                    lpErrno
                    );
            if ( NULL == tmpguid )
            {
                fprintf( stderr, "AddGuidToLspEntry: LspAlloc failed: %d\n", *lpErrno );
                goto cleanup;
            }

            memcpy( tmpguid, entry->LayeredGuids, sizeof(GUID) * entry->LayeredGuidCount );

            memcpy( &tmpguid[ entry->LayeredGuidCount ], guid, sizeof( GUID ) );

            LspFree( entry->LayeredGuids );

            entry->LayeredGuids = tmpguid;
            entry->LayeredGuidCount++;
        }
    }

    return NO_ERROR;

cleanup:

    return SOCKET_ERROR;
}

LSP_ENTRY* BuildLspMap	(	WSAPROTOCOL_INFOW *	pProviders,
		int	iProviderCount,
		int *	pLspCount
	)

Definition at line 110 of file lspmap.cpp.

{
    LSP_ENTRY *pLsps = NULL,
               lsptmp;
    DWORD     *pBaseList = NULL;
    int        iLspCount = 0,
               iSortLspCount = 0,
               iOrphanCount = 0,
               iBaseCount = 0,
               iProviderPathLen,
               ErrorCode,
               LspOrder,
               start,
               end,
               idx,
               rc,
               i, j, k;

    // Retrieve how many orphaned chain entries are present
    iOrphanCount = CountOrphanedChainEntries( pProviders, iProviderCount );

    // Retrieve the LSP count
    iSortLspCount = iLspCount = GetProviderCount( pProviders, iProviderCount, LAYERED_PROTOCOL );

    if ( ( 0 == iOrphanCount ) && ( 0 == iLspCount ) )
    {
        fprintf( stderr, "BuildLspMap: No LSP installed on the system!\n");
        goto cleanup;
    }

    // If orphaned entries are present, create another LSP_ENTRY and put all orphaned
    //      entries there.
    if ( iOrphanCount > 0 )
        iLspCount++;

    // Allocate space for our structure which represents the LSPs installed
    pLsps = (LSP_ENTRY *) LspAlloc(
            sizeof( LSP_ENTRY ) * iLspCount,
           &ErrorCode
            );
    if ( NULL == pLsps )
    {
        fprintf( stderr, "BuildLspMap: LspAlloc failed: %d\n", ErrorCode );
        goto cleanup;
    }

    // If orphaned entries are present, allocate space to hold them
    if ( iOrphanCount > 0 )
    {
        pLsps[ iLspCount-1 ].LayeredEntries = (WSAPROTOCOL_INFOW *)LspAlloc(
                sizeof(WSAPROTOCOL_INFOW) * iOrphanCount, &ErrorCode );
        if ( NULL == pLsps[ iLspCount-1 ].LayeredEntries )
        {
            fprintf( stderr, "BuildLspMap: LspAlloc failed: %d\n", ErrorCode );
            goto cleanup;
        }

        pLsps[ iLspCount-1 ].OrphanedEntries = TRUE;
        pLsps[ iLspCount-1 ].Count = iOrphanCount;

        //
        // Find the orphaned entries and save them off
        //
        idx = 0;
        for(i=0; i < iProviderCount ;i++)
        {
            // Only investigate protocol chain entries (i.e. chainlen > 1)
            if ( pProviders[ i ].ProtocolChain.ChainLen > 1 )
            {
                // Walk the catalog and look for the dummy entry (i.e. the ID in 
                //    chain entry 0)
                for(j=0; j < iProviderCount ;j++) 
                {
                    if ( i == j )
                        continue;

                    if ( pProviders[ i ].ProtocolChain.ChainEntries[ 0 ] ==
                         pProviders[ j ].dwCatalogEntryId )
                    {
                        break;
                    }
                }
                if ( j >= iProviderCount )
                {
                    // If j is past iProviderCount, no match was found so this is
                    //    an orphaned entry...save it off
                    memcpy( &pLsps[ iLspCount-1 ].LayeredEntries[ idx ],
                            &pProviders[ i ],
                             sizeof( WSAPROTOCOL_INFOW )
                          );
                    rc = AddGuidToLspEntry( &pLsps[ iLspCount-1 ], &pProviders[ i ].ProviderId,
                            &ErrorCode );
                    if ( SOCKET_ERROR == rc )
                    {
                        fprintf( stderr, "BuildLspMap: AddGuidToLspEntry failed: %d\n", ErrorCode );
                        goto cleanup;
                    }
                        
                    idx++;
                }
            }
        }
    }

    //
    // Build a list of the valid LSPs installed on the system
    //
    idx = 0;
    for(i=0; i < iProviderCount ;i++)
    {
        if ( LAYERED_PROTOCOL == pProviders[ i ].ProtocolChain.ChainLen )
        {
            // Copy the dummy entry
            memcpy( &pLsps[ idx ].DummyEntry, &pProviders[ i ], sizeof( WSAPROTOCOL_INFOW ) );

            // Get the DLL path
            iProviderPathLen = MAX_PATH-1;
            rc = WSCGetProviderPath(
                    &pLsps[ idx ].DummyEntry.ProviderId,
                     pLsps[ idx ].wszLspDll,
                    &iProviderPathLen,
                    &ErrorCode
                     );
            if ( SOCKET_ERROR == rc )
            {
                fprintf( stderr, "BuildLspMap: WSCGetProviderPath failed: %d\n", ErrorCode );
                goto cleanup;
            }

            //
            // Now go find all the layered entries associated with the dummy provider
            //

            // First get the count
            for(j=0; j < iProviderCount ;j++)
            {
                //
                // Compare only the first entry against the dummy ID. Otherwise, 
                //    we may pick up more than the provider's owned by this LSP 
                //    (it may pick up other providers layered over this LSP.
                //
                if ( ( pProviders[ j ].ProtocolChain.ChainLen > 1 ) &&
                     ( pProviders[ j ].ProtocolChain.ChainEntries[ 0 ] ==
                       pLsps[ idx ].DummyEntry.dwCatalogEntryId ) 
                   )
                // if ( IsIdInChain( &pProviders[ j ], pLsps[ idx ].DummyEntry.dwCatalogEntryId ) )
                {
                    pLsps[idx].Count++;
                }
            }

            // Allocate space
            pLsps[ idx ].LayeredEntries = (WSAPROTOCOL_INFOW *) LspAlloc(
                    sizeof( WSAPROTOCOL_INFOW ) * pLsps[ idx ].Count,
                   &ErrorCode
                    );
            if ( NULL == pLsps[ idx ].LayeredEntries )
            {
                fprintf( stderr, "BuildLspMap: LspAlloc failed: %d\n", ErrorCode );
                goto cleanup;
            }

            pLsps[ idx ].LayerChanged = (int *) LspAlloc(
                    sizeof( int ) * pLsps[ idx ].Count,
                   &ErrorCode
                    );
            if ( NULL == pLsps[ idx ].LayerChanged )
            {
                fprintf( stderr, "BuildLspMap: LspAlloc failed: %d\n", ErrorCode );
                goto cleanup;
            }

            // Now go find the entries
            pLsps[idx].Count = 0;
            for(j=0; j < iProviderCount ;j++)
            {
                if ( ( pProviders[ j ].ProtocolChain.ChainLen > 1 ) &&
                     ( pProviders[ j ].ProtocolChain.ChainEntries[ 0 ] ==
                       pLsps[ idx ].DummyEntry.dwCatalogEntryId ) 
                   )
                {
                    memcpy( 
                           &pLsps[ idx ].LayeredEntries[pLsps[ idx ].Count],
                           &pProviders[ j ],
                            sizeof( WSAPROTOCOL_INFOW )
                            );

                    pLsps[idx].MaxChainLength = MAX( 
                            pLsps[ idx ].MaxChainLength,
                            pLsps[ idx ].LayeredEntries[ pLsps[idx].Count ].ProtocolChain.ChainLen 
                            );

                    // Mark this entry as visited
                    pProviders[ j ].dwProviderReserved = 1;

                    // Keep track of how many GUIDs are used to install the layered entries
                    rc = AddGuidToLspEntry( &pLsps[ idx ], &pProviders[ j ].ProviderId, &ErrorCode );
                    if ( SOCKET_ERROR == rc )
                    {
                        fprintf( stderr, "BuildLspMap: AddGuidToLspEntry failed: %d\n", ErrorCode );
                        goto cleanup;
                    }

                    pLsps[ idx ].Count++;
                }
            }

            pLsps[ idx ].LspOrder = MAX_PROTOCOL_CHAIN;

            idx++;      // Increment index into the map
        }
    }

    //
    // We now have an array of "LSPs" -- now order them
    //

    // First get a list of base provider IDs
    iBaseCount = GetProviderCount( pProviders, iProviderCount, BASE_PROTOCOL );
    if ( 0 == iBaseCount )
    {
        fprintf( stderr, "BuildLspMap: GetProviderCount(BASE_PROTOCOL) returned zero!\n" );
        goto cleanup;
    }

    // Allocate space for the array of base provider ID's
    pBaseList = (DWORD *) LspAlloc(
            sizeof( DWORD ) * iBaseCount,
           &ErrorCode
            );
    if ( NULL == pBaseList )
    {
        fprintf( stderr, "BuildLspMap: HeapAlloc failed: %d\n", ErrorCode );
        goto cleanup;
    }

    //
    // Copy the base provider ID's to our array -- this array contains the catalog
    // IDs of only base providers which will be used next to determine the order
    // in which LSPs were installed.
    //
    idx = 0;
    for(i=0; i < iProviderCount ;i++)
    {
        if ( BASE_PROTOCOL == pProviders[ i ].ProtocolChain.ChainLen )
        {
            pBaseList[ idx++ ] = pProviders[ i ].dwCatalogEntryId;
        }
    }

    //
    // For each layered protocol entry of an LSP find the lowest index in the protocol
    // chain where a base provider resides. A protocol chain should always terminate
    // in a base provider.
    //
    for(LspOrder = 1; LspOrder < MAX_PROTOCOL_CHAIN ;LspOrder++)
    {
        for(i=0; i < iSortLspCount ;i++)
        {
            for(j=0; j < pLsps[ i ].Count ;j++)
            {
                for(k=0; k < iBaseCount ;k++)
                {
                    if ( pLsps[ i ].LayeredEntries[ j ].ProtocolChain.ChainEntries[ LspOrder ] ==
                         pBaseList[ k ] )
                    {
                        pLsps[ i ].LspOrder = MIN( pLsps[ i ].LspOrder, LspOrder );
                        break;
                    }
                }
            }
        }
    }

    //
    // Sort the entries according to the LspOrder field
    //
    for(i=0; i < iSortLspCount ;i++)
    {
        for(j=i; j < iSortLspCount ;j++)
        {
            if ( pLsps[ i ].LspOrder > pLsps[ j ].LspOrder )
            {
                // Exchange positions
                memcpy( &lsptmp,     &pLsps[ i ], sizeof( LSP_ENTRY ) );
                memcpy( &pLsps[ i ], &pLsps[ j ], sizeof( LSP_ENTRY ) );
                memcpy( &pLsps[ j ], &lsptmp,     sizeof( LSP_ENTRY ) );
            }
        }
    }

    //
    // Now need to sort by MaxChainLength withing the LspOrder groupings
    //
    for(LspOrder=1; LspOrder < MAX_PROTOCOL_CHAIN ;LspOrder++)
    {
        // Find the start and end positions within the array for the given
        // LspOrder value
        start = -1;
        end   = -1;

        for(i=0; i < iSortLspCount ;i++)
        {
            if ( pLsps[ i ].LspOrder == LspOrder )
            {
                start = i;
                break;
            }
        }

        //
        // Find the end position which is the LSP Map entry whose LspOrder
        // value doesn't match the current one. This will give us the range
        // of LSP entries whose LspOrder value is identical -- we need to
        // sort the LSPs of the same LspOrder according to the MaxChainLength
        //
        if ( -1 != start )
        {
            for(j=start; j < iSortLspCount ;j++)
            {
                if ( pLsps[ j ].LspOrder != LspOrder )
                {
                    end = j - 1;
                    break;
                }
            }
        }
        
        //
        // If the following is true then all entries have the same order
        // value. We still need to sort by MaxChainLength so set the end
        // to the last LSP 
        //
        if ( ( -1 != start ) && ( -1 == end ) )
        {
            end = iSortLspCount - 1;
        }

        if ( ( -1 != start ) && ( -1 != end ) )
        {
            for(i=start; i < end ;i++)
            {
                for(j=i; j < end ;j++)
                {
                    if ( pLsps[ i ].MaxChainLength > pLsps[ j ].MaxChainLength )
                    {
                        memcpy( &lsptmp,     &pLsps[ i ], sizeof( LSP_ENTRY ) );
                        memcpy( &pLsps[ i ], &pLsps[ j ], sizeof( LSP_ENTRY ) );
                        memcpy( &pLsps[ j ], &lsptmp,     sizeof( LSP_ENTRY ) );
                    }
                }
            }
        }
    }

    // Add the LSP dependency info to the map
    rc = LspDependencyCheck( pLsps, iSortLspCount );
    if ( SOCKET_ERROR == rc )
    {
        FreeLspMap( pLsps, iLspCount );
        pLsps = NULL;
        iLspCount = 0;
        goto cleanup;
    }

cleanup:
    
    if ( NULL != pLspCount )
        *pLspCount = iLspCount;

    if ( NULL != pBaseList )
        LspFree( pBaseList );

    return pLsps;
}

void FreeLspMap	(	LSP_ENTRY *	pLspMap,
		int	iLspCount
	)

Definition at line 583 of file lspmap.cpp.

{
    int     i;

    for(i=0; i < iLspCount ;i++)
    {
        // Free the layered providers first
        if ( NULL != pLspMap[ i ].LayeredEntries )
            LspFree( pLspMap[ i ].LayeredEntries );

        if ( NULL != pLspMap[ i ].LayeredGuids )
            LspFree( pLspMap[ i ].LayeredGuids );

        if ( NULL != pLspMap[ i ].LayerChanged )
            LspFree( pLspMap[ i ].LayerChanged );

        if ( NULL != pLspMap[ i ].DependentLspIndexArray )
            LspFree( pLspMap[ i ].DependentLspIndexArray );
    }
    LspFree( pLspMap );
}

int LspDependencyCheck	(	LSP_ENTRY *	pLspMap,
		int	iLspCount
	)

Definition at line 621 of file lspmap.cpp.

{
    BOOL        bDependent;
    int         iCheckLspIndex = 0,
                ret = SOCKET_ERROR,
               *tmpArray = NULL,
                ErrorCode,
                i, j, k, l;

    // For each LSP entry, find its dependencies
    for(i=0; i < iLspCount ;i++)
    {
        iCheckLspIndex = i;

        // Search all other LSPs for dependencies on this entry
        for(j=0; j < iLspCount ;j++)
        {
            // Skip checking against the same one were currently looking at
            if ( j == iCheckLspIndex )
                continue;

            bDependent = FALSE;

            // Check the dummy catalog entry against all the chains for the LSP we're
            // currently looking at
            for(k=0; k < pLspMap[ j ].Count ;k++)
            {
                if ( IsIdInChain(
                           &pLspMap[ j ].LayeredEntries[ k ],
                            pLspMap[ iCheckLspIndex ].DummyEntry.dwCatalogEntryId )
                   )
                {
                    // Allocate an array for the dependent LSP indices
                    tmpArray = (int *) LspAlloc(
                            sizeof( int ) * ( pLspMap[ iCheckLspIndex ].DependentCount + 1),
                           &ErrorCode
                            );
                    if ( NULL == tmpArray )
                    {
                        fprintf( stderr, "CheckLspDependency: LspAlloc failed: %d\n", ErrorCode );
                        goto cleanup;
                    }

                    // If one already exists, copy the existing array into the new one
                    if ( NULL != pLspMap[ iCheckLspIndex ].DependentLspIndexArray )
                    {
                        memcpy( 
                                tmpArray + 1,
                                pLspMap[ iCheckLspIndex ].DependentLspIndexArray,
                                sizeof( int ) * pLspMap[ iCheckLspIndex ].DependentCount
                                );

                        // Free the existing array
                        LspFree( pLspMap[ iCheckLspIndex ].DependentLspIndexArray );
                    }
                    
                    // Assign the new array and increment the count
                    pLspMap[ iCheckLspIndex ].DependentLspIndexArray = tmpArray;
                    pLspMap[ iCheckLspIndex ].DependentLspIndexArray[ 0 ] = j;
                    pLspMap[ iCheckLspIndex ].DependentCount++;

                    bDependent = TRUE;
                }
            }

            //
            // If a dependency already exists, don't bother checking the layered protocol
            // chains for one
            //
            if ( TRUE == bDependent )
                continue;

            //
            // Now check whether each layered protocol entry ID is present in any
            // of the layered protocol entry chains of the LSP we're currently
            // looking at.
            //
            for(l=0; l < pLspMap[ iCheckLspIndex ].Count ;l++)
            {
                bDependent = FALSE;

                // Check against each layered entry
                for(k=0; k < pLspMap[ j ].Count ;k++ )
                {
                    if ( IsIdInChain(
                           &pLspMap[ j ].LayeredEntries[ k ],
                            pLspMap[ iCheckLspIndex ].LayeredEntries[ l ].dwCatalogEntryId )
                       )
                    {
                        {
                            tmpArray = (int *) LspAlloc(
                                    sizeof( int ) * ( pLspMap[ iCheckLspIndex ].DependentCount + 1),
                                    &ErrorCode
                                    );
                            if ( NULL == tmpArray )
                            {
                                fprintf( stderr, "CheckLspDependency: LspAlloc failed: %d\n", ErrorCode );
                                goto cleanup;
                            }

                            if ( NULL != pLspMap[ iCheckLspIndex ].DependentLspIndexArray )
                            {
                                memcpy( 
                                        tmpArray + 1,
                                        pLspMap[ iCheckLspIndex ].DependentLspIndexArray,
                                        sizeof( int ) * pLspMap[ iCheckLspIndex ].DependentCount
                                      );

                                LspFree( pLspMap[ iCheckLspIndex ].DependentLspIndexArray );
                            }

                            pLspMap[ iCheckLspIndex ].DependentLspIndexArray = tmpArray;
                            pLspMap[ iCheckLspIndex ].DependentLspIndexArray[ 0 ] = j;
                            pLspMap[ iCheckLspIndex ].DependentCount++;

                            bDependent = TRUE;
                            break;
                        }
                    }
                }

                if ( TRUE == bDependent )  
                    break;
            }
        }
    }
    
    ret = NO_ERROR;

cleanup:

    return ret;
}

void MapNewEntriesToOld	(	LSP_ENTRY *	pEntry,
		WSAPROTOCOL_INFOW *	pProvider,
		int	iProviderCount
	)

Definition at line 817 of file lspmap.cpp.

{
    int     i, j;

    for(i=0; i < pEntry->Count ;i++)
    {
        for(j=0; j < iProviderCount ;j++)
        {
            if ( IsEqualProtocolEntries( &pEntry->LayeredEntries[ i ], &pProvider[ j ] ) )
            {
                pEntry->LayeredEntries[ i ].dwProviderReserved = 
                        pProvider[ j ].dwCatalogEntryId;

                dbgprint( "Mapped old %d to new %d\n",
                        pEntry->LayeredEntries[ i ].dwCatalogEntryId,
                        pProvider[ j ].dwCatalogEntryId
                        );

                break;
            }
        }
    }
}

int MaxLayeredChainCount	(	LSP_ENTRY *	pLspMap,
		int	LspCount
	)

Definition at line 971 of file lspmap.cpp.

{
    int MaxSize = 0,
        i;

    for(i=0; i < LspCount ;i++)
    {
        MaxSize = MAX( MaxSize, pLspMap[ i ].Count );
    }

    return MaxSize;
}

void PrintLspMap	(	LSP_ENTRY *	pLspMap,
		int	iLspCount
	)

Definition at line 498 of file lspmap.cpp.

{
    WCHAR   szGuidString[ MAX_PATH ];
    int     i, j, k;

    if ( NULL == pLspMap )
    {
        printf( "\tNo LSPs currently installed\n\n" );
        goto cleanup;
    }
  
    for(i=0; i < iLspCount ;i++)
    {
        if ( pLspMap[ i ].OrphanedEntries != TRUE )
        {
            // Display the LSP name and its DLL (and path)
            printf( "%3d LSP: %ws   DLL '%ws' ID: %d\n", 
                    i, 
                    pLspMap[ i ].DummyEntry.szProtocol,
                    pLspMap[ i ].wszLspDll,
                    pLspMap[ i ].DummyEntry.dwCatalogEntryId
                    );

            // Display the GUIDs under which the layered entries of this LSP are installed
            printf( "\t LSP Installed under %d GUIDs\n", pLspMap[ i ].LayeredGuidCount );
            for(k=0; k < pLspMap[ i ].LayeredGuidCount ;k++)
            {
                StringFromGUID2( pLspMap[ i ].LayeredGuids[ k ], szGuidString, MAX_PATH-1 );
                printf( "\t\t%ws\n", szGuidString );
            }
        }
        else
        {
            printf("Orphaned layered chain entries:\n");
        }

        // Display the layered entries and the protocol chains
        for(j=0; j < pLspMap[ i ].Count ;j++)
        {
            printf( "\t Layer %-5d \"%ws\" \n\t       Chain %d [ ", 
                    pLspMap[ i ].LayeredEntries[ j ].dwCatalogEntryId,
                    pLspMap[ i ].LayeredEntries[ j ].szProtocol,
                    pLspMap[ i ].LayeredEntries[ j ].ProtocolChain.ChainLen
                    );

            for(k=0; k < pLspMap[ i ].LayeredEntries[ j ].ProtocolChain.ChainLen ;k++)
            {
                printf( "%d ", pLspMap[ i ].LayeredEntries[ j ].ProtocolChain.ChainEntries[ k ] );
            }
            printf( "]\n" );
        }

        // Display any LSPs which depend on this one (i.e. other LSPs layered over this one)
        printf( "\t Dependent LSPs:\n" );
        if ( pLspMap[ i ].DependentCount == 0 )
            printf( "\t\tNone\n");
        else
        {
            for(j=0; j < pLspMap[ i ].DependentCount ;j++)
            {
                printf("\t\t%d %ws\n",
                        pLspMap[ pLspMap[ i ].DependentLspIndexArray[ j ] ].DummyEntry.dwCatalogEntryId,
                        pLspMap[ pLspMap[ i ].DependentLspIndexArray[ j ] ].DummyEntry.szProtocol
                        );
            }
        }

        printf( "\n" );
    }

cleanup:

    return;
}

void PrintProviders	(	WINSOCK_CATALOG	Catalog,
		BOOL	bLayeredOnly,
		BOOL	bVerbose
	)

Definition at line 35 of file lspmap.cpp.

{
    WSAPROTOCOL_INFOW  *pProtocolInfo = NULL;
    INT                 iProtocolCount = 0,
                        i;

    // Enumerate catalog and print it
    pProtocolInfo = EnumerateProviders( Catalog, &iProtocolCount );
    if ( NULL == pProtocolInfo )
    {
        fprintf( stderr, "PrintProviders: Unable to enumerate catalog!\n" );
        goto cleanup;
    }

    for(i=0; i < iProtocolCount ;i++)
    {
        if ( FALSE == bLayeredOnly )
        {
            // Print all providers
            if ( TRUE == bVerbose )
                PrintProtocolInfo( &pProtocolInfo[ i ] );
            else
                printf("%04d - %S\n", 
                        pProtocolInfo[ i ].dwCatalogEntryId,
                        pProtocolInfo[ i ].szProtocol
                        );
        }
        else if ( LAYERED_PROTOCOL == pProtocolInfo[ i ].ProtocolChain.ChainLen )
        {
            // Print only layered providers
            if ( TRUE == bVerbose )
                PrintProtocolInfo( &pProtocolInfo[ i ] );
            else
                printf("%04d - %S\n", 
                        pProtocolInfo[ i ].dwCatalogEntryId,
                        pProtocolInfo[ i ].szProtocol
                        );
        }
    }
    
cleanup:

    if ( NULL != pProtocolInfo )
        FreeProviders( pProtocolInfo );

    return;
}

void UpdateLspMap	(	LSP_ENTRY *	pLspMap,
		DWORD	dwOldValue,
		DWORD	dwNewValue
	)

Definition at line 773 of file lspmap.cpp.

{
    int i, j;

    // Go through all providers beloging to this LSP
    for(i=0; i < pLspMap->Count ;i++)
    {
        // Go through the protocol chain and update references if they match
        for(j=0; j < pLspMap->LayeredEntries[ i ].ProtocolChain.ChainLen ;j++)
        {
            if ( pLspMap->LayeredEntries[ i ].ProtocolChain.ChainEntries[ j ] == 
                    dwOldValue 
               )
            {
                pLspMap->LayeredEntries[ i ].ProtocolChain.ChainEntries[ j ] = 
                        dwNewValue;
            }
        }
    }

    return;
}

void UpdateProviderOrder	(	LSP_ENTRY *	UpdatedEntry,
		DWORD *	OrderArray,
		int	ArrayCount
	)

Definition at line 939 of file lspmap.cpp.

{
    int     i, j;


    for(i=0; i < UpdatedEntry->Count ;i++)
    {
        for(j=0; j < ArrayCount ;j++)
        {
            // Replace an occurence of the old value with the new value
            if ( OrderArray[ j ] == UpdatedEntry->LayeredEntries[ i ].dwCatalogEntryId )
            {
                OrderArray[ j ] = UpdatedEntry->LayeredEntries[ i ].dwProviderReserved;
            }
        }
    }
}