void main(int argc, char *argv[])
{
if(argc==2)
{
if(strcmp(argv[1], "-install")==0)
{
TCHAR szPathName[256];
TCHAR* p;
if(::GetFullPathName(L"LSP.dll", 256, szPathName, &p) != 0)
{
if(InstallProvider(szPathName))
{
printf(" Install successully. \n");
return;
}
}
printf(" Install failed. \n");
return;
}
else if(strcmp(argv[1],"-remove")==0)
{
if(RemoveProvider())
printf(" Deinstall successully. \n");
else
printf(" Deinstall failed. \n");
return;
}
}
printf(" Usage: Instlsp [ -install │ -remove ] \n");
}
void CSyssetPage::OnInstall() // 用户点击"安装"按钮
{
TCHAR szPathName[256];
TCHAR* p;
// 注意，安装LSP需要使用完整DLL路径。这样的话，CPIOControl类在加载DLL时也应使用
// 完整路径，否则CPIOControl类加载的DLL不能和作为LSP的DLL共享内存
if(::GetFullPathName(PHOENIX_SERVICE_DLL_NAME, 256, szPathName, &p) != 0)
{
if(InstallProvider(szPathName))
{
MessageBox(L" 应用层过滤安装成功！");
return;
}
}
MessageBox(L" 应用层过滤安装失败！");
}
void main(int argc, char *argv[])
{
char szFileName[256];
char szPathName[256];
char* p;
if(argc == 3)
{
strcpy(szFileName,argv[2]);
if(strcmp(argv[1], "-install")==0)
{
if(::GetFileAttributes(szFileName) == -1)
{
printf("Error:Can't Find File!\n");
return;
}
if(::GetFullPathName(szFileName, 256, szPathName, &p) != 0)
{
if(InstallProvider(szPathName))
{
printf("\nInstall Successully!\n");
return;
}
}
printf("\nInstall Failed -> %d\n",::GetLastError());
return;
}
else if(strcmp(argv[1],"-remove")==0)
{
if(RemoveProvider())
printf("\nRemove Successully!\n");
else
printf("\nRemove Failed -> %d\n",::GetLastError());
return;
}
}
printf(" Usage: test.exe [ -install │ -remove ] DllName\n");
printf("\n\teg:test.exe -install LSP.dll\n");
printf("\tor:test.exe -remove LSP.dll\n");
printf("\n");
}
//
// Function: InstallNonIfsLspProtocolChains
//
// Description:
// This function builds and install the protocol chain entries associated with
// a non-IFS LSP. The caling routine installs the dummy, hidden entry in the
// catalog and this routine enumerates the catalog, finds the dummy entry,
// builds the layered chain entries, and installs them into the catalog.
//
int
InstallNonIfsLspProtocolChains(
WINSOCK_CATALOG eCatalog,
GUID *Guid,
WCHAR *lpszLspName,
WCHAR *lpszLspFullPathAndFile,
DWORD *pdwCatalogIdArray,
DWORD dwCatalogIdArrayCount
)
{
WSAPROTOCOL_INFOW *pProvider = NULL,
*pLayeredEntries = NULL;
DWORD dwDummyLspId = 0;
INT iProviderCount = 0,
retval = SOCKET_ERROR,
idx,
err,
rc,
i, j;
HRESULT hr;
// Enumerate the catalog
pProvider = EnumerateProviders( eCatalog, &iProviderCount );
if ( NULL == pProvider )
{
fprintf( stderr, "InstallNonIfsLspProtocolChain: Unable to enumerate catalog\n" );
goto cleanup;
}
pLayeredEntries = (WSAPROTOCOL_INFOW *) LspAlloc( sizeof(WSAPROTOCOL_INFOW) *
dwCatalogIdArrayCount, &err );
if ( NULL == pLayeredEntries )
{
fprintf( stderr, "InstallNonIfsLspProtocolChain: LspAlloc failed: %d\n", err );
goto cleanup;
}
// Find the dummy entry so we can extract its catalog ID
dwDummyLspId = GetCatalogIdForProviderGuid( Guid, pProvider, iProviderCount );
ASSERT( dwDummyLspId != 0 );
// Go through the catalog and build the layered entries
idx = 0;
for(i=0; i < iProviderCount ;i++)
{
for(j=0; j < (int) dwCatalogIdArrayCount ;j++)
{
if ( pProvider[ i ].dwCatalogEntryId == pdwCatalogIdArray[ j ] )
{
if ( pProvider[ i ].ProtocolChain.ChainLen >= ( MAX_PROTOCOL_CHAIN - 1 ) )
{
fprintf( stderr, "InstallNonIfsLspProtocolchain: Too many LSPs installed!\n");
goto cleanup;
}
memcpy( &pLayeredEntries[ idx ], &pProvider[ i ], sizeof( WSAPROTOCOL_INFOW ) );
// Put our LSP name in the protocol field
hr = StringCchPrintfW( pLayeredEntries[ idx ].szProtocol, WSAPROTOCOL_LEN,
L"%s over [%s]",
lpszLspName,
pProvider[ i ].szProtocol
);
if ( FAILED( hr ) )
{
fprintf( stderr, "InstallNonIfsLspProtocolChain: StringCchPrintfW failed: 0x%x\n", hr );
goto cleanup;
}
// Move all the protocol chain entries down by 1 position and insert
// the dummy entry id at the head
InsertIdIntoProtocolChain( &pLayeredEntries[ idx ], 0, dwDummyLspId );
// The second entry is always the ID of the current pProvider[i]
// In case of multiple LSPs then if we didn't do this the [1] index
// would contain the ID of that LSP's dummy entry and not the entry
// itself.
pLayeredEntries[ idx ].ProtocolChain.ChainEntries[ 1 ] =
pProvider[ i ].dwCatalogEntryId;
// Remove the IFS flag
pLayeredEntries[ idx ].dwServiceFlags1 &= (~XP1_IFS_HANDLES);
idx++;
}
}
}
for(i=0; i < (int)dwCatalogIdArrayCount ;i++)
{
// Create a GUID for the protocol chain entries
if ( UuidCreate( &pLayeredEntries[ i ].ProviderId ) != RPC_S_OK )
{
fprintf(stderr, "InstallNonIfsLspProtocolChains: UuidCreate failed: %d\n", GetLastError());
goto cleanup;
}
// Install the layered chain providers
rc = InstallProvider(
eCatalog,
&pLayeredEntries[ i ].ProviderId,
lpszLspFullPathAndFile,
&pLayeredEntries[ i ],
1
);
if ( NO_ERROR != rc )
{
fprintf(stderr, "InstallNonIfsLspProtocolChains: Unable to install layered chain entries!\n");
goto cleanup;
}
}
// Reorder the winsock catalog so the layered chain entries appear first
rc = ReorderCatalog( eCatalog, dwDummyLspId );
if ( NO_ERROR != rc )
{
fprintf(stderr, "InstallNonIfsLspProtocolChains: Unable to reorder Winsock catalog!\n");
goto cleanup;
}
retval = NO_ERROR;
cleanup:
if ( NULL != pProvider )
FreeProviders( pProvider );
if ( NULL != pLayeredEntries )
LspFree( pLayeredEntries );
return retval;
}
//
// Function: InstallIfsLspProtocolChains
//
// Description:
// This routine installs the layered protocol chains for an IFS based LSP. It
// assumes the LSP dummy entry is already installed. This function first enumerates
// the catalog to find the ID of the dummy entry. It then builds the protocol
// entries for the IFS layered protocols. Note that an IFS entry must be installed
// such that no non-IFS providers are layered beneath it. This means if the user
// chooses to install the IFS LSP over a provider which includes non-IFS layers, it
// must insert itself into the chain such that it is below all non-IFS providers.
// This means that existing entries need to be modified in order to reflect this
// ordering. Also in the event that the IFS LSP is inserted into an existing chain
// this installer still builds a series of standalone entries (i.e. entries that
// would have existed of the LSPs layered over the IFS LSP were installed after
// the IFS LSP was).
//
int
InstallIfsLspProtocolChains(
WINSOCK_CATALOG eCatalog,
GUID *Guid,
WCHAR *lpszLspName,
WCHAR *lpszLspFullPathAndFile,
DWORD *pdwCatalogIdArray,
DWORD dwCatalogIdArrayCount
)
{
WSAPROTOCOL_INFOW *pProvider = NULL,
*pProviderNew = NULL,
*pLayeredEntries = NULL,
*pEntry = NULL,
TempEntry = {0};
DWORD *pProviderOrder = NULL,
dwDummyLspId;
WCHAR wszLspDll[ MAX_PATH ];
BOOL bLayeredOverNonIfs = FALSE,
bContainsNonIfs = FALSE;
HRESULT hr;
int ProviderPathLen = MAX_PATH-1,
iProviderCount,
iProviderCountNew,
LayerIdx,
retval = SOCKET_ERROR,
err,
idx,
rc,
i, j, k;
// Enumerate the catalog
pProvider = EnumerateProviders( eCatalog, &iProviderCount );
if ( NULL == pProvider )
{
fprintf( stderr, "InstallIfsLspProtocolChains: Unable to enumerate catalog\n" );
goto cleanup;
}
// Find the dummy, hidden entry of our new LSP
dwDummyLspId = GetCatalogIdForProviderGuid( Guid, pProvider, iProviderCount );
ASSERT( dwDummyLspId != 0 );
// Allocate space for the protocol chains of the new LSP
pLayeredEntries = (WSAPROTOCOL_INFOW *) LspAlloc( sizeof(WSAPROTOCOL_INFOW) *
dwCatalogIdArrayCount, &err );
if ( NULL == pLayeredEntries )
{
fprintf( stderr, "InstallIfsLspProtocolChains: LspAlloc failed: %d\n", err );
goto cleanup;
}
LayerIdx = 0;
// Build the layered protocol entries as well as a list of those providers which
// require modification. Whenever an LSP is installed, a number of protocol entries
// are installed where the first entry in the chain array is the LSP's dummy entry.
// Addtionally, if we're installing an IFS LSP over an provider whose protocol chain
// includes non-IFS LSPs, the IFS LSP must be placed in the chain such that no
// non-IFS LSPs are positioned after it in the chain.
// Loop through each ID we're layering over
for(i=0; i < (int)dwCatalogIdArrayCount ;i++)
{
for(j=0; j < iProviderCount ;j++)
{
printf("Matching selected ID %d to catalog %d\n",
pdwCatalogIdArray[ i ], pProvider[ j ].dwCatalogEntryId );
if ( pdwCatalogIdArray[ i ] == pProvider[ j ].dwCatalogEntryId )
{
// Verify the entry has room enough to be layered over
if ( pProvider[ j ].ProtocolChain.ChainLen >= ( MAX_PROTOCOL_CHAIN - 1 ) )
{
fprintf( stderr, "InstallIfsLspProtocolChain: Too many LSPs installed!\n");
goto cleanup;
}
// Save off the entry which we're layering over
memcpy( &pLayeredEntries[ LayerIdx ], &pProvider[ j ],
sizeof( pLayeredEntries[ 0 ] ) );
memcpy( &TempEntry, &pProvider[ j ], sizeof( TempEntry ) );
// Fill in the new LSP entry's name
hr = StringCchPrintfW( pLayeredEntries[ LayerIdx ].szProtocol, WSAPROTOCOL_LEN,
L"%s over [%s]",
lpszLspName,
pProvider[ j ].szProtocol
);
if ( FAILED( hr ) )
{
fprintf( stderr, "InstallIfsLspProtocolChains: StringCchPrintfW failed: 0x%x\n", hr );
goto cleanup;
}
// Check whether the selected entry contains non IFS LSPs in its chain
if ( pProvider[ j ].ProtocolChain.ChainLen >= 2 )
{
for(k=pProvider[ j ].ProtocolChain.ChainLen-2 ; k >= 0 ;k--)
{
bContainsNonIfs = IsNonIfsProvider( pProvider, iProviderCount,
pProvider[ j ].ProtocolChain.ChainEntries[ k ] );
if ( TRUE == bContainsNonIfs )
{
// Need to modify the pProvider entry to reference the
// added LSP entry within its chain
// In the 'modified' array make a space at location after 'k'
InsertIdIntoProtocolChain( &pProvider[ j ], k+1, UPDATE_LSP_ENTRY );
// Save the index to the layer which corresponds to this entry
pProvider[ j ].dwProviderReserved = LayerIdx + 1;
// Need to fix the 'pLayeredEntry' as well
BuildSubsetLspChain( &pLayeredEntries[ LayerIdx ], k+1, dwDummyLspId );
pLayeredEntries[ LayerIdx ].dwServiceFlags1 |= XP1_IFS_HANDLES;
bLayeredOverNonIfs = TRUE;
// Need to insert the IFS provider in all LSPs that are layered
// above the location where the IFS provider was just inserted
InsertIfsLspIntoAllChains( &TempEntry, pProvider, iProviderCount,
LayerIdx + 1, k );
break;
}
}
}
// Need to setup the protocol chain in the pLayeredEntry if we haven't
// already done so above
if ( TRUE != bContainsNonIfs )
{
InsertIdIntoProtocolChain( &pLayeredEntries[ LayerIdx ], 0, dwDummyLspId );
// The second entry is always the ID of the current pProvider[i]
// In case of multiple LSPs then if we didn't do this the [1] index
// would contain the ID of that LSP's dummy entry and not the entry
// itself.
pLayeredEntries[ LayerIdx ].ProtocolChain.ChainEntries[ 1 ] =
TempEntry.dwCatalogEntryId;
pLayeredEntries[ LayerIdx ].dwServiceFlags1 |= XP1_IFS_HANDLES;
}
LayerIdx++;
}
}
}
ASSERT( LayerIdx == (int)dwCatalogIdArrayCount );
// Create a unique GUID for each provider to install and install it
for(i=0;i < (int)dwCatalogIdArrayCount ;i++)
{
if ( RPC_S_OK != UuidCreate( &pLayeredEntries[ i ].ProviderId ) )
{
fprintf(stderr, "InstallIfsLspProtocolChains: UuidCreate failed: %d\n", GetLastError());
goto cleanup;
}
rc = InstallProvider( eCatalog, &pLayeredEntries[ i ].ProviderId,
lpszLspFullPathAndFile, &pLayeredEntries[ i ], 1 );
if ( NO_ERROR != rc )
{
fprintf(stderr, "InstallIfsLspProtocolChains: Unable to install the dummy LSP entry!\n");
goto cleanup;
}
}
if ( TRUE == bLayeredOverNonIfs )
{
// Enumerate the catalog again so we can find the catalog IDs
pProviderNew = EnumerateProviders( eCatalog, &iProviderCountNew );
if ( NULL == pProvider )
{
fprintf( stderr, "InstallIfsLspProtocolChains: Unable to enumerate catalog\n" );
goto cleanup;
}
for(i=0; i < (int)dwCatalogIdArrayCount ;i++)
{
pLayeredEntries[ i ].dwCatalogEntryId = GetCatalogIdForProviderGuid(
&pLayeredEntries[ i ].ProviderId,
pProviderNew,
iProviderCountNew
);
ASSERT( pLayeredEntries[ i ].dwCatalogEntryId != 0 );
}
// Update the protocol chains of the modified entries to point to the just
// installed providers
for(i=0; i < iProviderCount ;i++)
{
if ( pProvider[ i ].dwProviderReserved == 0 )
continue;
for(j=0; j < pProvider[ i ].ProtocolChain.ChainLen ;j++)
{
if ( UPDATE_LSP_ENTRY == pProvider[ i ].ProtocolChain.ChainEntries[ j ] )
{
pProvider[ i ].ProtocolChain.ChainEntries[ j ] =
pLayeredEntries[ pProvider[ i ].dwProviderReserved - 1 ].dwCatalogEntryId;
pProvider[ i ].dwProviderReserved = 0;
}
}
// Get the DLL path
ProviderPathLen = MAX_PATH-1;
rc = WSCGetProviderPath(
&pProvider[ i ].ProviderId,
wszLspDll,
&ProviderPathLen,
&err
);
if ( SOCKET_ERROR == rc )
{
fprintf( stderr, "InstallIfsLspProtocolChains: WSCGetProviderPath failed: %d\n", err );
goto cleanup;
}
// Update the providers which were modified
rc = UpdateProvider( eCatalog, &pProvider[ i ].ProviderId,
wszLspDll, &pProvider[ i ], 1, &err );
if ( SOCKET_ERROR == rc )
{
fprintf( stderr, "InstallIfsLspProtocolChains: UpdateProvider failed: %d\n", err );
goto cleanup;
}
printf("Updated entry ID: %d: %S (chain len = %d)\n",
pProvider[ i ].dwCatalogEntryId,
pProvider[ i ].szProtocol,
pProvider[ i ].ProtocolChain.ChainLen
);
}
FreeProviders( pProvider );
pProvider = NULL;
FreeProviders( pProviderNew );
pProviderNew = NULL;
/*
{
WSADATA wsd;
WSACleanup();
WSAStartup( MAKEWORD(2,2), &wsd );
}
*/
pProvider = EnumerateProviders( eCatalog, &iProviderCount );
if ( NULL == pProvider )
{
fprintf( stderr, "InstallIfsLspProtocolChains: Unable to enumerate catalog\n" );
goto cleanup;
}
// Allocate an array of DWORDs to contain the new catalog ordering
pProviderOrder = (DWORD *)LspAlloc( iProviderCount * sizeof(DWORD), &err );
if ( NULL == pProviderOrder )
{
fprintf( stderr, "InstallIfsLspProtocolChains: Unable to enumerate catalog\n" );
goto cleanup;
}
// First add the entries we layered over first
idx = 0;
for(i=0; i < (int)dwCatalogIdArrayCount ;i++)
{
pEntry = FindProviderById( pdwCatalogIdArray[ i ], pProvider, iProviderCount );
if ( NULL == pEntry )
{
fprintf(stderr, "InstallIfsLspProtocolChain: Unable to find entry to reorder catalog!\n");
goto cleanup;
}
pEntry->dwProviderReserved = 1;
pProviderOrder[ idx++ ] = pEntry->dwCatalogEntryId;
}
// Now go through the protocol chain of the entries we layered over and put those
// LSP entries next in the new order
for(i=0; i < (int)dwCatalogIdArrayCount ;i++)
{
pEntry = FindProviderById( pdwCatalogIdArray[ i ], pProvider, iProviderCount );
if ( NULL == pEntry )
{
fprintf(stderr, "InstallIfsLspProtocolChain: Unable to find entry to reorder catalog!\n");
goto cleanup;
}
printf("Looping through: %d: %S (chain len = %d)\n",
pEntry->dwCatalogEntryId,
pEntry->szProtocol,
pEntry->ProtocolChain.ChainLen );
for(j=1; j < pEntry->ProtocolChain.ChainLen-1 ;j++)
{
dwDummyLspId = FindDummyIdFromProtocolChainId(
pEntry->ProtocolChain.ChainEntries[ j ],
pProvider,
iProviderCount
);
printf(" Finding dummy ID for chain entry: %d is %d\n",
pEntry->ProtocolChain.ChainEntries[ j ],
dwDummyLspId
);
for(k=0; k < iProviderCount ;k++)
{
if ( ( pProvider[ k ].ProtocolChain.ChainLen >= 2 ) &&
( pProvider[ k ].ProtocolChain.ChainEntries[ 0 ] == dwDummyLspId ) &&
( pProvider[ k ].dwProviderReserved == 0 )
)
{
pProviderOrder[ idx++ ] = pProvider[ k ].dwCatalogEntryId;
pProvider[ k ].dwProviderReserved = 1;
printf(" Adding: %d\n", pProvider[ k ].dwCatalogEntryId );
}
}
}
}
// Now any catalog entry that wasn't already copied, copy it
for(i=0; i < iProviderCount ;i++)
{
if ( pProvider[ i ].dwProviderReserved == 0 )
pProviderOrder[ idx++ ] = pProvider[ i ].dwCatalogEntryId;
}
ASSERT( idx == iProviderCount );
// Write the new catalog order
rc = WriteProviderOrder( eCatalog, pProviderOrder, iProviderCount, &err );
if ( NO_ERROR != rc )
{
fprintf( stderr, "InstallIfsLspProtocolChains: WriteProviderOrder failed: %d\n",
err );
goto cleanup;
}
}
else
{
//
// Reorder the winsock catalog so the layered chain entries appear first.
// Since we didn't have to modify any existing entries, all we need to do is
// move the added entries to the head of the catalog
//
rc = ReorderCatalog( eCatalog, dwDummyLspId );
if ( NO_ERROR != rc )
{
fprintf(stderr, "InstallIfsLspProtocolChains: Unable to reorder Winsock catalog!\n");
goto cleanup;
}
}
retval = NO_ERROR;
cleanup:
if ( NULL != pProvider )
{
FreeProviders( pProvider );
pProvider = NULL;
}
if ( NULL != pProviderNew )
{
FreeProviders( pProviderNew );
pProviderNew = NULL;
}
if ( NULL != pProviderOrder )
{
LspFree( pProviderOrder );
pProviderOrder = NULL;
}
return retval;
}
//
// Function: InstallLsp
//
// Description:
// This function installs the LSP over each of the catalog IDs supplied in
// the pdwCatalogIdArray into the given Winsock catalog (since there are
// two catalogs on WIN64 platforms). This routine first installs the layered
// protocol entry (the dummy hidden provider) followed by installing the
// layered protocol chains.
//
int
InstallLsp(
WINSOCK_CATALOG eCatalog, // Which catalog to install LSP into
char *lpszLspName, // String name of LSP
char *lpszLspPathAndFile, // Location of LSP dll and dll name
DWORD dwCatalogIdArrayCount, // Number of entries in pdwCatalogIdArray
DWORD *pdwCatalogIdArray, // Array of IDs to install over
BOOL IfsProvider
)
{
WSAPROTOCOL_INFOW *pProtocolInfo = NULL,
*pDummyEntry = NULL,
*pLayeredEntries = NULL;
WCHAR wszLspName[ WSAPROTOCOL_LEN ],
wszFullProviderPath[ MAX_PATH+1 ];
GUID ProviderBaseGuid;
INT rc = SOCKET_ERROR;
//
// Install the LSP over the given entries. If selected to install over all
// entries, then enumerate the catalog to obtain all the available providers.
//
if ( NULL == lpszLspName )
{
lpszLspName = DEFAULT_LSP_NAME;
}
// Convert the LSP name to UNICODE since the Winsock catalog is all UNICODE
rc = MultiByteToWideChar(
CP_ACP,
0,
lpszLspName,
(int) strlen( lpszLspName ) + 1,
wszLspName,
WSAPROTOCOL_LEN
);
if (rc == 0)
{
fprintf(stderr, "InstallLsp: MultiByteToWideChar failed to convert '%s'; Error = %d\n",
lpszLspName, GetLastError());
goto cleanup;
}
rc = MultiByteToWideChar(
CP_ACP,
0,
lpszLspPathAndFile,
(int) strlen( lpszLspPathAndFile ) + 1,
wszFullProviderPath,
MAX_PATH
);
if ( 0 == rc )
{
fprintf( stderr, "InstallLsp: MultiByteToWidechar failed to convert '%s': Error = %d\n",
lpszLspPathAndFile, GetLastError() );
goto cleanup;
}
// Verify there's at least one entry to layer over
if ( 0 == dwCatalogIdArrayCount )
{
fprintf(stderr, "InstallLsp: Error! Must specify at least one provider to layer over!\n\n");
goto cleanup;
}
printf("LSP name is '%S'\n", wszLspName);
// Create the 'dummy' protocol entry
pDummyEntry = CreateDummyEntry( eCatalog, pdwCatalogIdArray[ 0 ], wszLspName, IfsProvider );
if (pDummyEntry == NULL)
{
fprintf(stderr, "InstallLsp: CreateDummyEntry failed!\n");
goto cleanup;
}
RetrieveLspGuid( lpszLspPathAndFile, &ProviderBaseGuid );
// Install the 'dummy' protocol entry for the LSP
rc = InstallProvider(
eCatalog,
&ProviderBaseGuid,
wszFullProviderPath,
pDummyEntry,
1
);
if ( NO_ERROR != rc )
{
fprintf(stderr, "InstallLsp: Unable to install the dummy LSP entry!\n");
goto cleanup;
}
// Don't need this struture any more
LspFree( pDummyEntry );
pDummyEntry = NULL;
if ( FALSE == IfsProvider )
{
rc = InstallNonIfsLspProtocolChains( eCatalog, &ProviderBaseGuid, wszLspName,
wszFullProviderPath, pdwCatalogIdArray, dwCatalogIdArrayCount );
}
else
{
rc = InstallIfsLspProtocolChains( eCatalog, &ProviderBaseGuid, wszLspName,
wszFullProviderPath, pdwCatalogIdArray, dwCatalogIdArrayCount );
}
if ( SOCKET_ERROR == rc )
{
// An error occured installing the chains so remove the dummy entry
DeinstallProvider( eCatalog, &ProviderBaseGuid );
}
cleanup:
if ( NULL != pProtocolInfo )
FreeProviders( pProtocolInfo );
if ( NULL != pDummyEntry )
LspFree( pDummyEntry );
if ( NULL != pLayeredEntries )
LspFree( pLayeredEntries );
return rc;
}
//
// Function: RemoveProvider
//
// Description:
// This function removes a layered provider. Things can get tricky if
// we're removing a layered provider which has been layered over by
// another provider. This routine first creates the LSP map to determine
// if other LSPs on the system reference the LSP we want to remove. If
// there are we must fix those LSPs before deleting the target LSP.
// If we're on a platform that supports WSCUpdateProvider its simply a
// matter of removing any reference to the target LSP's layered protocol
// chains and the dummy hidden entry.
//
// If we're not on a WSCUpdateProvider enabled system, then its very tricky.
// We must uninstall the dependent LSPs first followed by reinstalling them
// in the same order they were originally installed. For example if LSP1,
// LSP2, and LSP3 are installed (in that order) and this routine is invoked
// to remove LSP1, we must uninstall LSP3 and LSP2 followed by re-installing
// (LSP2 first then LSP3). For each LSP added back we must fix up the protocol
// chains of the next higher LSP so the reference the new catalog IDs (since
// the action of installing an LSP assigns a new catalog ID).
//
// NOTE: If WSCUpdateProvider is not supported there is the possiblity of
// another process changing the Winsock catalog at the same time we're
// trying to fix it back up. If this occurs it is possible for the
// corruption to occur.
//
int
RemoveProvider(
WINSOCK_CATALOG Catalog, // Catalog to remove an LSP from
DWORD dwProviderId // Catalog ID of LSPs hidden entry
)
{
WSAPROTOCOL_INFOW *pProvider = NULL,
*pLayeredEntries = NULL;
LSP_ENTRY *pLspMap = NULL,
*pLspMapEntryDel = NULL;
DWORD *pdwCatalogOrder = NULL;
INT iProviderCount = 0,
iLayerCount = 0,
iLspCount = 0,
ErrorCode,
Status,
rc,
i, j, k, l;
Status = SOCKET_ERROR;
// Enumerate the catalog
pProvider = EnumerateProviders( Catalog, &iProviderCount );
if ( pProvider == NULL )
{
fprintf( stderr, "RemoveProvider: Unable to enumerate catalog!\n" );
goto cleanup;
}
// Allocate an array to save of the provider order in case we have to
// do uninstall and reinstall providers
pdwCatalogOrder = (DWORD *) LspAlloc(
sizeof( DWORD ) * iProviderCount,
&ErrorCode
);
if ( NULL == pdwCatalogOrder )
{
fprintf( stderr, "RemoveProvider: LspAlloc failed: %d\n", ErrorCode );
goto cleanup;
}
for(i=0; i < iProviderCount ; i++)
{
pdwCatalogOrder[ i ] = pProvider[ i ].dwCatalogEntryId;
}
// Build a map of the LSPs installed on the system
pLspMap = BuildLspMap( pProvider, iProviderCount, &iLspCount );
if ( NULL == pLspMap )
{
fprintf( stderr, "RemoveProvider: Unable to build LSP map!\n" );
goto cleanup;
}
// Validate the catalog entry ID to remove
pLspMapEntryDel = NULL;
for(i=0; ( i < iLspCount ) && ( NULL == pLspMapEntryDel ) ; i++)
{
if ( dwProviderId == pLspMap[ i ].DummyEntry.dwCatalogEntryId )
{
pLspMapEntryDel = &pLspMap[ i ];
}
else
{
for(j=0; j < pLspMap[ i ].Count ; j++)
{
if ( dwProviderId == pLspMap[ i ].LayeredEntries[ j ].dwCatalogEntryId )
{
// In this case the user supplied the catalog ID of an LSP protocol
// chain entry -- not the hidden layered entry (dummy). Here we'll
// reset the dwProviderId to that of the dummy hidden entry.
//
if ( pLspMap[ i ].OrphanedEntries != TRUE )
{
printf( "Catalog ID %d is a layered protocol entry and not the hidden\n"
"provider representing the entire LSP. The LSP which owns this\n"
"provider is ID %d (%ws). This entire LSP will be removed!\n",
dwProviderId,
pLspMap[ i ].DummyEntry.dwCatalogEntryId,
pLspMap[ i ].DummyEntry.szProtocol
);
dwProviderId = pLspMap[ i ].DummyEntry.dwCatalogEntryId;
pLspMapEntryDel = &pLspMap[ i ];
}
else
{
printf( "Catalog ID %d is one of %d orphaned protocol entries.\n"
"These entries could be causing serious problems and\n"
"will be removed. The following providers are to be\n"
"deleted:\n",
pLspMap[ i ].LayeredEntries[ j ].dwCatalogEntryId,
pLspMap[ i ].Count
);
for(k=0; k < pLspMap[ i ].Count ; k++)
{
printf(" %d: %ws\n",
pLspMap[ i ].LayeredEntries[ k ].dwCatalogEntryId,
pLspMap[ i ].LayeredEntries[ k ].szProtocol
);
}
pLspMapEntryDel = &pLspMap[ i ];
}
break;
}
}
}
}
// Make sure we found a provider to remove
if ( NULL == pLspMapEntryDel )
{
fprintf( stderr, "\n\nError! Invalid Winsock catalog ID supplied: %d\n",
dwProviderId
);
goto cleanup;
}
//
// Print which entries are being removed
//
printf( "\nThe following LSP entries will be removed:\n" );
if ( pLspMapEntryDel->OrphanedEntries != TRUE )
{
printf( "LSP Hidden ID: %6d Name %ws\n",
pLspMapEntryDel->DummyEntry.dwCatalogEntryId,
pLspMapEntryDel->DummyEntry.szProtocol
);
}
else
{
printf( "Orphaned LSP protocol chain entries:\n");
}
for(i=0; i < pLspMapEntryDel->Count ; i++)
{
printf( "LSP Layer ID: %6d Name %ws\n",
pLspMapEntryDel->LayeredEntries[ i ].dwCatalogEntryId,
pLspMapEntryDel->LayeredEntries[ i ].szProtocol
);
}
ErrorCode = NO_ERROR;
if ( 0 != pLspMapEntryDel->DependentCount )
{
int iLspIdx;
printf( "\n\nOther LSPs are dependent on this one! "
"Additional cleanup is required..\n\n" );
for(i=0; i < pLspMapEntryDel->DependentCount ; i++)
{
iLspIdx = pLspMapEntryDel->DependentLspIndexArray[ i ];
printf( "Fixing LSP index %d: %ws\n",
pLspMap[ iLspIdx ].DummyEntry.dwCatalogEntryId,
pLspMap[ iLspIdx ].DummyEntry.szProtocol
);
// Remove any reference to the deleted LSPs dummy catalog ID
for(j=0; j < pLspMap[ iLspIdx ].Count ; j++)
{
if ( IsIdInChain( &pLspMap[ iLspIdx ].LayeredEntries[ j ],
pLspMapEntryDel->DummyEntry.dwCatalogEntryId )
)
{
printf( "Removing ID %d from layered chain %d: %ws\n",
pLspMapEntryDel->DummyEntry.dwCatalogEntryId,
pLspMap[ iLspIdx ].LayeredEntries[ j ].dwCatalogEntryId,
pLspMap[ iLspIdx ].LayeredEntries[ j ].szProtocol
);
// Remove the deleted LSPs ID from the chain
rc = RemoveIdFromChain(
&pLspMap[ iLspIdx ].LayeredEntries[ j ],
pLspMapEntryDel->DummyEntry.dwCatalogEntryId
);
if ( FALSE == rc )
{
fprintf( stderr, "RemoveProvider: ID not found in chain!\n" );
continue;
}
pLspMap[ iLspIdx ].LayerChanged[ j ] = TRUE;
}
}
// Remove any reference to the deleted LSPs layered entries catalog
// IDs from the layers of the dependent LSP
for(l=0; l < pLspMapEntryDel->Count ; l++)
{
for(j=0; j < pLspMap[ iLspIdx ].Count ; j++)
{
if ( IsIdInChain( &pLspMap[ iLspIdx ].LayeredEntries[ j ],
pLspMapEntryDel->LayeredEntries[ l ].dwCatalogEntryId )
)
{
printf( "Removing ID %d from layered chain %d: %ws\n",
pLspMapEntryDel->DummyEntry.dwCatalogEntryId,
pLspMap[ iLspIdx ].LayeredEntries[ j ].dwCatalogEntryId,
pLspMap[ iLspIdx ].LayeredEntries[ j ].szProtocol
);
// Remove the deleted LSPs ID from the chain
rc = RemoveIdFromChain(
&pLspMap[ iLspIdx ].LayeredEntries[ j ],
pLspMapEntryDel->LayeredEntries[ l ].dwCatalogEntryId
);
if ( FALSE == rc )
{
fprintf( stderr, "RemoveProvider: ID not found in chain!\n" );
continue;
}
pLspMap[ iLspIdx ].LayerChanged[ j ] = TRUE;
}
}
}
}
//
// All dependent LSPs should no longer reference any of the LSPs IDs which is
// to be removed. Now we must write our changes back to the catalog. Life
// is easy if we're on a system that supports WSCUpdateProvider.
//
if ( NULL != fnWscUpdateProvider )
{
//
// Life is good, simply call UpdateProvider on each entry in the LSP map
// that was updated.
//
for(i=0; i < pLspMapEntryDel->DependentCount ; i++)
{
iLspIdx = pLspMapEntryDel->DependentLspIndexArray[ i ];
for(j=0; j < pLspMap[ iLspIdx ].Count; j++)
{
if ( TRUE == pLspMap[ iLspIdx ].LayerChanged[ j ] )
{
rc = UpdateProvider(
Catalog,
&pLspMap[ iLspIdx ].LayeredEntries[ j ].ProviderId,
pLspMap[ iLspIdx ].wszLspDll,
&pLspMap[ iLspIdx ].LayeredEntries[ j ],
1,
&ErrorCode
);
}
}
}
}
else // fnWscUpdateProvider == NULL
{
int MaxLayers = 0;
//
// Life isn't so good. We need to remove all dependent LSPs first in the
// reverse order they were installed so that if something fails, we
// won't leave the catalog in a bad state. Then we need to reinstall
// them in the same order they were originally installed and fix any
// of the remaining dependent LSPs to reference the correct catalog IDs
// before they are also reinstalled.
//
// Find the maximum protocol chain length of all the LSPs since we need
// scratch space. We do the allocation first before making changes to
// the catalog.
MaxLayers = MaxLayeredChainCount(
pLspMap,
iLspCount
);
pLayeredEntries = (WSAPROTOCOL_INFOW *) LspAlloc(
sizeof( WSAPROTOCOL_INFOW ) * MaxLayers,
&ErrorCode
);
if ( NULL == pLayeredEntries )
{
fprintf( stderr, "RemoveProvider: LspAlloc failed: %d\n",
ErrorCode );
goto cleanup;
}
// Remove the dependent LSPs in reverse order. NOTE: We don't have to
// remove the dummy hidden entries since there is no information
// in those providers that need updating.
for(i=0; i < pLspMapEntryDel->DependentCount ; i++)
{
iLspIdx = pLspMapEntryDel->DependentLspIndexArray[ i ];
for(j=0; j < pLspMap[ iLspIdx ].LayeredGuidCount ; j++)
{
rc = DeinstallProvider(
Catalog,
&pLspMap[ iLspIdx ].LayeredGuids[ j ]
);
if ( SOCKET_ERROR == rc )
{
fprintf( stderr,
"RemoveProvider: An error occured trying to remove an LSP.\n"
"\t\tThis may be due to another process changing the Catalog\n"
"\t\tAborting...\n"
);
goto cleanup;
}
}
}
// All the dependent LSP layers have been removed, now add them
// back in reverse order
for(i=pLspMapEntryDel->DependentCount-1; i >= 0 ; i--)
{
iLspIdx = pLspMapEntryDel->DependentLspIndexArray[ i ];
// Install the layered entries
for(j=0; j < pLspMap[ iLspIdx ].LayeredGuidCount ; j++)
{
iLayerCount = MaxLayers;
rc = GetLayeredEntriesByGuid(
pLayeredEntries,
&iLayerCount,
pLspMap[ iLspIdx ].LayeredEntries,
pLspMap[ iLspIdx ].Count,
&pLspMap[ iLspIdx ].LayeredGuids[ j ]
);
rc = InstallProvider(
Catalog,
&pLspMap[ iLspIdx ].LayeredGuids[ j ],
pLspMap[ iLspIdx ].wszLspDll,
pLayeredEntries,
iLayerCount
);
}
// Enumerate catalog to find new IDs
DWORD ProviderLen = iProviderCount * sizeof( WSAPROTOCOL_INFOW );
int NewProviderCount = EnumerateProvidersExisting(
Catalog,
pProvider,
&ProviderLen
);
if ( SOCKET_ERROR == NewProviderCount )
{
fprintf( stderr, "RemoveProvider: EnumerateProvidersExisting failed: %d\n",
GetLastError() );
}
// Update the old references to the new
MapNewEntriesToOld(
&pLspMap[ iLspIdx ],
pProvider,
NewProviderCount
);
// Update the provider order array with the new provider values
UpdateProviderOrder(
&pLspMap[ iLspIdx ],
pdwCatalogOrder,
iProviderCount
);
// For the remaining LSPs which we still need to install, update any
// references to the removed LSPs with their new IDs
for(k=i-1; k >= 0 ; k--)
{
int iLspIdx2 = pLspMapEntryDel->DependentLspIndexArray[ k ];
printf( "Updating IDs for index %d\n", iLspIdx2 );
for(l=0; l < pLspMap[ iLspIdx ].Count ; l++)
{
UpdateLspMap(
&pLspMap[ iLspIdx2 ],
pLspMap[ iLspIdx ].LayeredEntries[ l ].dwCatalogEntryId,
pLspMap[ iLspIdx ].LayeredEntries[ l ].dwProviderReserved
);
}
}
}
// Reorder the catalog back to what it was before. Since we've added
// back all the LSPs we removed earlier, the catalog should be the
// same size as when we started.
rc = WriteProviderOrder(
Catalog,
pdwCatalogOrder,
iProviderCount,
&ErrorCode
);
if ( SOCKET_ERROR == rc )
{
fprintf( stderr, "RemoveProvider: WriteProviderOrder failed: %d\n",
ErrorCode );
}
}
}
//
// Now all dependencies have been fixed, remove the specified provider
//
// Remove the layered protocol entries
for(i=0; i < pLspMapEntryDel->LayeredGuidCount ; i++)
{
rc = DeinstallProvider(
Catalog,
&pLspMapEntryDel->LayeredGuids[ i ]
);
}
// Remove the dummy entry
rc = DeinstallProvider(
Catalog,
&pLspMapEntryDel->DummyEntry.ProviderId
);
Status = NO_ERROR;
cleanup:
//
// Cleanup allocations
//
if ( NULL != pLayeredEntries )
LspFree( pLayeredEntries );
if ( NULL != pProvider )
FreeProviders(pProvider);
if ( NULL != pLspMap )
FreeLspMap( pLspMap, iLspCount );
if ( NULL != pdwCatalogOrder )
LspFree( pdwCatalogOrder );
return Status;
}
