|
|
//----------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
// All rights reserved.
//
// File Name:
// netreg.cpp
//
// Description:
// This file contains the calls to the Network Component Object interfaces
// to find out what network clients, services and protocols are installed
// on the current machine and what their settings are.
//
//----------------------------------------------------------------------------
#include "pch.h"
#include "netreg.h"
//
// Constants
//
const static INT MAX_GUID_STRING = 40;const static INT MAX_NUM_NET_COMPONENTS = 128;const static INT BUFFER_SIZE = 4096; //
// Registry fields used to read settings for network components
//
const static TCHAR REGVAL_DOMAIN[] = _T("Domain");const static TCHAR REGVAL_INTERFACES[] = _T("Interfaces");const static TCHAR REGVAL_ENABLE_DHCP[] = _T("EnableDHCP");const static TCHAR REGVAL_IPADDRESS[] = _T("IPAddress");const static TCHAR REGVAL_SUBNETMASK[] = _T("SubnetMask");const static TCHAR REGVAL_DEFAULTGATEWAY[] = _T("DefaultGateway");const static TCHAR REGVAL_NAMESERVER[] = _T("NameServer");const static TCHAR REGVAL_WINS[] = _T("SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters\\Interfaces\\Tcpip_");const static TCHAR REGVAL_NAMESERVERLIST[] = _T("NameServerList");
const static TCHAR REGKEY_MSCLIENT_LOCATION[] = _T("SOFTWARE\\Microsoft\\Rpc\\NameService");const static TCHAR REGVAL_NAME_SERVICE_PROVIDER[] = _T("Protocol");const static TCHAR REGVAL_NETWORK_ADDRESS[] = _T("NetworkAddress");
const static TCHAR REGVAL_ADAPTERS[] = _T("Adapters");const static TCHAR REGVAL_PKT_TYPE[] = _T("PktType");const static TCHAR REGVAL_NETWORK_NUMBER[] = _T("NetworkNumber");const static TCHAR REGVAL_VIRTUAL_NETWORK_NUMBER[] = _T("VirtualNetworkNumber");
//----------------------------------------------------------------------------
//
// Function: ReadNetworkRegistrySettings
//
// Purpose: In general, this function reads in all the necessary networking
// settings and sets the internal variables appropriately. This includes
// determining how many network adapters there are, what
// client/services/protocols are installed and loading their individual
// settings.
//
// When reads from the registry fail, it just moves on to try and get the
// next setting. The failed one is just left with its default. In this
// way if just one registry entry is broken all the other data will be
// obtained rather than just quiting the function.
//
// Arguments: VOID
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
EXTERN_C HRESULTReadNetworkRegistrySettings( VOID ){ HRESULT hr = S_OK; INetCfg* pNetCfg = NULL;
//
// Always force a Custom net setting if they are reading from the registry
// because I don't want to write the code to see if their current net
// configuration is a typical one (when 99.9% of the time it won't be)
//
NetSettings.iNetworkingMethod = CUSTOM_NETWORKING;
hr = InitializeInterfaces( &pNetCfg );
if( FAILED( hr ) ) { return( E_FAIL ); }
hr = GetNetworkAdapterSettings( pNetCfg );
if( FAILED( hr ) ) {
ReleaseInterfaces( pNetCfg );
return( E_FAIL );
}
//
// Purposely not catching return values here. Call each one to try and
// grab as many parameters as we can. If we hit an error just move on
// and try to grab the next value.
//
GetClientsInstalled( pNetCfg ); GetServicesInstalled( pNetCfg ); GetProtocolsInstalled( pNetCfg );
ReleaseInterfaces( pNetCfg );
GetDomainOrWorkgroup();
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetNetworkAdapterSettings
//
// Purpose: Determines how many network cards are installed and gets there
// PnP Ids. It then stores these in the appropriate global variables.
//
// Arguments: INetCfg *pNetCfg - pointer to a NetCfg object that is already
// created and initialized
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT GetNetworkAdapterSettings( INetCfg *pNetCfg ){
UINT i; INetCfgComponent* arrayComp[MAX_NUM_NET_COMPONENTS]; IEnumNetCfgComponent* pEnum = NULL; INetCfgClass* pNetCfgClass = NULL; INetCfgComponent* pNetCfgComp = NULL; NETWORK_ADAPTER_NODE* pPreviousNode = NULL; NETWORK_ADAPTER_NODE* pCurrentNode = NULL; HRESULT hr = S_OK; DWORD dwCharacteristics = 0; ULONG iCount = 0;
hr = InitializeComInterface( &GUID_DEVCLASS_NET, pNetCfg, pNetCfgClass, pEnum, arrayComp, &iCount );
if( FAILED( hr ) ) { return( hr ); }
//
// delete the entire list of Network Adapters so we can start fresh
//
DeleteList( NetSettings.NetworkAdapterHead );
NetSettings.NetworkAdapterHead = NULL;
NetSettings.iNumberOfNetworkCards = 0;
AssertMsg( iCount <= MAX_NUM_NET_COMPONENTS, "Too many network components to work with" );
for( i = 0; i < iCount; i++ ) {
pNetCfgComp = arrayComp[i];
hr = ChkInterfacePointer( pNetCfgComp, IID_INetCfgComponent );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum );
return( hr );
}
hr = pNetCfgComp->GetCharacteristics( &dwCharacteristics );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum );
return( hr );
}
//
// If this is a physical adapter
//
if( dwCharacteristics & NCF_PHYSICAL ) {
NetSettings.iNumberOfNetworkCards++;
hr = SetupAdapter( &pCurrentNode, pNetCfgComp );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum );
return( hr );
}
//
// Adjust pointers to maintain the doubly linked-list
//
pCurrentNode->previous = pPreviousNode;
if( pPreviousNode != NULL ) {
pPreviousNode->next = pCurrentNode;
}
pPreviousNode = pCurrentNode;
}
if( pNetCfgComp ) {
pNetCfgComp->Release();
}
}
//
// if there is a network card in this machine, set the current network card
// to be the first one, else zero out the values
//
if( NetSettings.iNumberOfNetworkCards > 0 ) {
NetSettings.iCurrentNetworkCard = 1; NetSettings.pCurrentAdapter = NetSettings.NetworkAdapterHead;
} else {
NetSettings.iCurrentNetworkCard = 0; NetSettings.NetworkAdapterHead = NULL; NetSettings.pCurrentAdapter = NULL;
}
UninitializeComInterface( pNetCfgClass, pEnum );
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetClientsInstalled
//
// Purpose: For each client, it finds out if it is installed on the current
// system and if it is then it reads its settings from the registry
//
// Arguments: INetCfg *pNetCfg - pointer to a NetCfg object that is already
// created and initialized
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT GetClientsInstalled( INetCfg *pNetCfg ){
INetCfgComponent* arrayComp[MAX_NUM_NET_COMPONENTS]; IEnumNetCfgComponent* pEnum = NULL; INetCfgClass* pNetCfgClass = NULL; INetCfgComponent* pNetCfgComp = NULL; HRESULT hr = S_OK; ULONG iCount = 0; LPWSTR pszwDisplayName = NULL; HKEY hKey; UINT i;
NETWORK_COMPONENT* pMsClientComponent = NULL; NETWORK_COMPONENT* pNetwareComponent = NULL;
//
// Initialize each of the pointers to point into its proper place in the
// global network component list
//
pMsClientComponent = FindNode( MS_CLIENT_POSITION ); pNetwareComponent = FindNode( NETWARE_CLIENT_POSITION );
hr = InitializeComInterface( &GUID_DEVCLASS_NETCLIENT, pNetCfg, pNetCfgClass, pEnum, arrayComp, &iCount );
if( FAILED( hr ) ) { return( hr ); }
for( i = 0; i < iCount; i++ ) {
pNetCfgComp = arrayComp[i];
hr = ChkInterfacePointer( pNetCfgComp, IID_INetCfgComponent );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum ); return( hr );
}
hr = pNetCfgComp->GetDisplayName( &pszwDisplayName );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum ); return( hr );
}
if( lstrcmpi( pMsClientComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// set the component to Installed
//
pMsClientComponent->bInstalled = TRUE;
hr = pNetCfgComp->OpenParamKey( &hKey ); if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum ); return( hr );
} //
// grab Ms Client settings from the registry
//
ReadMsClientSettingsFromRegistry( &hKey );
RegCloseKey( hKey );
} else if( lstrcmpi( pNetwareComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// set the component to Installed
//
pNetwareComponent->bInstalled = TRUE;
hr = pNetCfgComp->OpenParamKey( &hKey ); if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum ); return( hr );
}
//
// grab Netware settings from the registry
//
ReadNetwareSettingsFromRegistry( &hKey );
RegCloseKey( hKey );
}
CoTaskMemFree( pszwDisplayName );
if( pNetCfgComp ) {
pNetCfgComp->Release();
}
}
UninitializeComInterface( pNetCfgClass, pEnum );
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetServicesInstalled
//
// Purpose: For each service, it finds out if it is installed on the current
// system and if it is then it sets its component to Installed = TRUE
//
// Arguments: INetCfg *pNetCfg - pointer to a NetCfg object that is already
// created and initialized
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT GetServicesInstalled( INetCfg *pNetCfg ){
INetCfgComponent* arrayComp[MAX_NUM_NET_COMPONENTS]; IEnumNetCfgComponent* pEnum = NULL; INetCfgClass* pNetCfgClass = NULL; INetCfgComponent* pNetCfgComp = NULL; LPWSTR pszwDisplayName = NULL; HRESULT hr = S_OK; ULONG iCount = 0; UINT i;
NETWORK_COMPONENT* pFilePrintSharingComponent = NULL; NETWORK_COMPONENT* pPacketSchedulingComponent = NULL;
//
// Initialize each of the pointers to point into its proper place in the
// global network component list
//
pFilePrintSharingComponent = FindNode( FILE_AND_PRINT_SHARING_POSITION ); pPacketSchedulingComponent = FindNode( PACKET_SCHEDULING_POSITION );
hr = InitializeComInterface( &GUID_DEVCLASS_NETCLIENT, pNetCfg, pNetCfgClass, pEnum, arrayComp, &iCount );
if( FAILED( hr ) ) { return( hr ); }
for( i = 0; i < iCount; i++ ) {
pNetCfgComp = arrayComp[i];
hr = ChkInterfacePointer( pNetCfgComp, IID_INetCfgComponent );
if( FAILED( hr ) ) { UninitializeComInterface( pNetCfgClass, pEnum ); return( hr ); }
hr = pNetCfgComp->GetDisplayName( &pszwDisplayName );
if( FAILED( hr ) ) { UninitializeComInterface( pNetCfgClass, pEnum ); return( hr ); } if( lstrcmpi( pFilePrintSharingComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// only have to set the component to Installed, no settings to read
//
pFilePrintSharingComponent->bInstalled = TRUE;
} else if( lstrcmpi( pPacketSchedulingComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// only have to set the component to Installed, no settings to read
//
pPacketSchedulingComponent->bInstalled = TRUE;
}
CoTaskMemFree( pszwDisplayName );
if( pNetCfgComp ) {
pNetCfgComp->Release();
}
}
UninitializeComInterface( pNetCfgClass, pEnum );
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetProtocolsInstalled
//
// Purpose: For each protocol, it finds out if it is installed on the current
// system and if it is then it reads its settings from the registry
//
// Arguments: INetCfg *pNetCfg - pointer to a NetCfg object that is already
// created and initialized
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT GetProtocolsInstalled( INetCfg *pNetCfg ){
INetCfgComponent* arrayComp[MAX_NUM_NET_COMPONENTS]; IEnumNetCfgComponent* pEnum = NULL; INetCfgClass* pNetCfgClass = NULL; INetCfgComponent* pNetCfgComp = NULL; LPWSTR pszwDisplayName = NULL; HKEY hKey = NULL; HRESULT hr = S_OK; ULONG iCount = 0; UINT i;
NETWORK_COMPONENT* pTcpipComponent = NULL; NETWORK_COMPONENT* pIpxComponent = NULL; NETWORK_COMPONENT* pNetBeuiComponent = NULL; NETWORK_COMPONENT* pDlcComponent = NULL; NETWORK_COMPONENT* pNetworkMonitorComponent = NULL; NETWORK_COMPONENT* pAppletalkComponent = NULL;
//
// Initialize each of the pointers to point into its proper place in the
// global network component list
//
pTcpipComponent = FindNode( TCPIP_POSITION ); pIpxComponent = FindNode( IPX_POSITION ); pNetBeuiComponent = FindNode( NETBEUI_POSITION ); pDlcComponent = FindNode( DLC_POSITION ); pNetworkMonitorComponent = FindNode( NETWORK_MONITOR_AGENT_POSITION ); pAppletalkComponent = FindNode( APPLETALK_POSITION );
hr = InitializeComInterface( &GUID_DEVCLASS_NETTRANS, pNetCfg, pNetCfgClass, pEnum, arrayComp, &iCount );
if( FAILED( hr ) ) { return( hr ); }
for( i = 0; i < iCount; i++ ) {
pNetCfgComp = arrayComp[i];
hr = ChkInterfacePointer( pNetCfgComp, IID_INetCfgComponent );
if( FAILED( hr ) ) {
UninitializeComInterface( pNetCfgClass, pEnum ); return( hr );
}
hr = pNetCfgComp->GetDisplayName( &pszwDisplayName );
if( FAILED( hr ) ) { UninitializeComInterface( pNetCfgClass, pEnum ); return( hr ); }
if( lstrcmpi( pTcpipComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// set the component to Installed
//
pTcpipComponent->bInstalled = TRUE;
hr = pNetCfgComp->OpenParamKey( &hKey ); if( SUCCEEDED( hr ) ) {
//
// grab TCP/IP settings from the registry
//
ReadTcpipSettingsFromRegistry( &hKey );
}
RegCloseKey( hKey );
} else if( lstrcmpi( pIpxComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// set the component to Installed
//
pIpxComponent->bInstalled = TRUE;
hr = pNetCfgComp->OpenParamKey( &hKey ); if( SUCCEEDED( hr ) ) {
// grab IPX settings from the registry
ReadIpxSettingsFromRegistry( &hKey );
}
RegCloseKey( hKey );
} else if( lstrcmpi( pNetBeuiComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// only have to set the component to Installed, no settings to read
//
pNetBeuiComponent->bInstalled = TRUE;
} else if( lstrcmpi( pDlcComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// only have to set the component to Installed, no settings to read
//
pDlcComponent->bInstalled = TRUE;
} else if( lstrcmpi( pNetworkMonitorComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// only have to set the component to Installed, no settings to read
//
pNetworkMonitorComponent->bInstalled = TRUE;
} else if( lstrcmpi( pAppletalkComponent->StrComponentName, pszwDisplayName ) == 0 ) {
//
// set the component to Installed
//
pAppletalkComponent->bInstalled = TRUE;
hr = pNetCfgComp->OpenParamKey( &hKey ); if( SUCCEEDED( hr ) ) {
// grab Appletalk settings from the registry
ReadAppletalkSettingsFromRegistry( &hKey );
}
RegCloseKey( hKey );
}
CoTaskMemFree( pszwDisplayName );
if( pNetCfgComp ) {
pNetCfgComp->Release();
}
}
UninitializeComInterface( pNetCfgClass, pEnum );
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetDomainOrWorkgroup
//
// Purpose: Find out if this machine is a member of a workgroup or domain and
// then fill the global structs with the proper name.
//
// Arguments: VOID
//
// Returns: VOID
//
//----------------------------------------------------------------------------
static VOIDGetDomainOrWorkgroup( VOID ) {
BOOL bDomain = FALSE; TCHAR szDomainOrWorkgroup[MAX_WORKGROUP_LENGTH + 1] = _T("");
//
// Get the domain/workgoup
//
if( LSA_SUCCESS( GetDomainMembershipInfo( &bDomain, szDomainOrWorkgroup ) ) ) {
if( bDomain ) { lstrcpyn( NetSettings.DomainName, szDomainOrWorkgroup, AS(NetSettings.DomainName) );
NetSettings.bWorkgroup = FALSE; } else { lstrcpyn( NetSettings.WorkGroupName, szDomainOrWorkgroup, AS(NetSettings.WorkGroupName) );
NetSettings.bWorkgroup = TRUE; }
}
}
//----------------------------------------------------------------------------
//
// Function: SetupAdapter
//
// Purpose: Allocates and initializes a new Network adapter struct, then reads
// the adapter's PnP Id and it's GUID.
//
// Arguments:
//
// Returns: HRESULT returns status of success or failure of the function
// On failure, the caller of this function is responsible for calling
// UninitializeComInterface()
//----------------------------------------------------------------------------
static HRESULTSetupAdapter( NETWORK_ADAPTER_NODE **ppCurrentNode, INetCfgComponent *pNetCfgComp ){
HRESULT hr = S_OK; LPWSTR pszwPnPID = NULL;
*ppCurrentNode = (NETWORK_ADAPTER_NODE *)malloc( sizeof( NETWORK_ADAPTER_NODE ) ); if (*ppCurrentNode == NULL) return (E_FAIL);
//
// Initialize all the Network namelists to 0s
//
ZeroOut( *ppCurrentNode );
//
// Set all network card settings to their default values
//
ResetNetworkAdapter( *ppCurrentNode );
if( NetSettings.iNumberOfNetworkCards == 1 ) { NetSettings.NetworkAdapterHead = *ppCurrentNode; }
//
// Get the Plug and Play Id
//
hr = pNetCfgComp->GetId( &pszwPnPID );
if( SUCCEEDED( hr ) ) {
hr=StringCchCopy( (*ppCurrentNode)->szPlugAndPlayID, AS((*ppCurrentNode)->szPlugAndPlayID), pszwPnPID );
CoTaskMemFree( pszwPnPID );
}
//
// Get the Guid for this network adapter
//
hr = pNetCfgComp->GetInstanceGuid( &((*ppCurrentNode)->guid) );
if( FAILED( hr ) ) {
//
// this call failed so any call to the registry will fail since it
// needs this guid
//
return( hr );
}
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: ReadNetwareSettingsFromRegistry
//
// Purpose: Read in registry settings on Netware and fill the global structs
// with the appropriate values
//
// Arguments: HKEY *hKey
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static VOIDReadNetwareSettingsFromRegistry( IN HKEY *hKey ){
REGSAM SecurityAccess = KEY_QUERY_VALUE;
// ISSUE-2002/02/28-stelo- write this function
}
//----------------------------------------------------------------------------
//
// Function: ReadMsClientSettingsFromRegistry
//
// Purpose: Read in registry settings on MS Client and fill the global structs
// with the appropriate values
//
// Arguments: HKEY *hKey
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static VOIDReadMsClientSettingsFromRegistry( IN HKEY *hKey ){
HKEY hNameServiceKey = NULL; REGSAM SecurityAccess = KEY_QUERY_VALUE; DWORD dwSize = 0;
TCHAR szBuffer[BUFFER_SIZE];
// ISSUE-2002/02/28-stelo- I don't use the hKey passed in. For some reason, the Network
// component objects don't point to the section of the registry I need
// to read from. Is this a bug with Network Component Objects?
dwSize = sizeof( szBuffer );
if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, REGKEY_MSCLIENT_LOCATION, 0, SecurityAccess, &hNameServiceKey ) != ERROR_SUCCESS ) {
//
// need this key to read in other MS Client values so bail if we
// can't get it
//
return;
}
if( RegQueryValueEx( hNameServiceKey, REGVAL_NAME_SERVICE_PROVIDER, NULL, NULL, (LPBYTE) szBuffer, &dwSize ) == ERROR_SUCCESS ) {
if ( LSTRCMPI(szBuffer, _T("ncacn_ip_tcp")) == 0 ) { NetSettings.NameServiceProvider = MS_CLIENT_DCE_CELL_DIR_SERVICE;
dwSize = sizeof( szBuffer );
if( RegQueryValueEx( hNameServiceKey, REGVAL_NETWORK_ADDRESS, 0, NULL, (LPBYTE) szBuffer, &dwSize) == ERROR_SUCCESS ) {
lstrcpyn( NetSettings.szNetworkAddress, szBuffer, MAX_NETWORK_ADDRESS_LENGTH + 1 );
}
} else { NetSettings.NameServiceProvider = MS_CLIENT_WINDOWS_LOCATOR; }
}
RegCloseKey( hNameServiceKey );
}
//----------------------------------------------------------------------------
//
// Function: ReadAppletalkSettingsFromRegistry
//
// Purpose: Read in registry settings on Appletalk and fill the global structs
// with the appropriate values
//
// Arguments: HKEY *hKey
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static VOIDReadAppletalkSettingsFromRegistry( IN HKEY *hKey ){
REGSAM SecurityAccess = KEY_QUERY_VALUE;
// ISSUE-2002/02/28-stelo- write this function
}
//----------------------------------------------------------------------------
//
// Function: ReadIpxSettingsFromRegistry
//
// Purpose: Read in registry settings on IPX and fill the global structs
// with the appropriate values
//
// Arguments: HKEY *hKey
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static VOIDReadIpxSettingsFromRegistry( IN HKEY *hKey ){
REGSAM SecurityAccess = KEY_QUERY_VALUE; HKEY hIpxAdaptersKey = NULL; HKEY hNetworkAdapterKey = NULL; DWORD dwSize = 0; NETWORK_ADAPTER_NODE *pNetAdapter = NULL;
WCHAR szStringGuid[MAX_GUID_STRING]; TCHAR szBuffer[BUFFER_SIZE];
if( RegOpenKeyEx( *hKey, REGVAL_ADAPTERS, 0, SecurityAccess, &hIpxAdaptersKey ) != ERROR_SUCCESS ) {
//
// need this key to read in other IPX values so bail if we can't get it
//
return;
}
dwSize = sizeof( szBuffer );
if( RegQueryValueEx( *hKey, REGVAL_VIRTUAL_NETWORK_NUMBER, 0, NULL, (LPBYTE) szBuffer, &dwSize ) == ERROR_SUCCESS ) {
lstrcpyn( NetSettings.szInternalNetworkNumber, szBuffer, MAX_INTERNAL_NET_NUMBER_LEN + 1 );
}
//
// For each Network Adapter, load its IPX settings
//
for( pNetAdapter = NetSettings.NetworkAdapterHead; pNetAdapter; pNetAdapter = pNetAdapter->next ) {
StringFromGUID2( pNetAdapter->guid, szStringGuid, StrBuffSize( szStringGuid ) );
if( RegOpenKeyEx( hIpxAdaptersKey, szStringGuid, 0, SecurityAccess, &hNetworkAdapterKey ) == ERROR_SUCCESS ) {
dwSize = sizeof( szBuffer );
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_PKT_TYPE, 0, NULL, (LPBYTE) szBuffer, &dwSize) == ERROR_SUCCESS ) {
lstrcpyn( pNetAdapter->szFrameType, _T("0x"), AS(pNetAdapter->szFrameType) );
lstrcatn( pNetAdapter->szFrameType, szBuffer, MAX_FRAMETYPE_LEN );
}
dwSize = sizeof( szBuffer );
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_NETWORK_NUMBER, 0, NULL, (LPBYTE) szBuffer, &dwSize) == ERROR_SUCCESS ) {
lstrcpyn( pNetAdapter->szNetworkNumber, szBuffer, MAX_NET_NUMBER_LEN + 1 );
}
} }}
//----------------------------------------------------------------------------
//
// Function: ReadTcpipSettingsFromRegistry
//
// Purpose: Read in registry settings on TCP/IP and fill the global structs
// with the appropriate values
//
// Arguments: HKEY *hKey -
//
// Returns: HRESULT returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static VOIDReadTcpipSettingsFromRegistry( IN HKEY *hKey ){
HKEY hTcpipInterfaceKey = NULL; REGSAM SecurityAccess = KEY_QUERY_VALUE;
NETWORK_ADAPTER_NODE *pNetAdapter = NULL;
if( RegOpenKeyEx( *hKey, REGVAL_INTERFACES, 0, SecurityAccess, &hTcpipInterfaceKey ) != ERROR_SUCCESS ) {
//
// need this key to read in all other TCP/IP values so bail if we can't get it
//
return;
}
//
// For each Network Adapter, load its TCP/IP settings
//
for( pNetAdapter = NetSettings.NetworkAdapterHead; pNetAdapter; pNetAdapter = pNetAdapter->next ) {
ReadAdapterSpecificTcpipSettings( hTcpipInterfaceKey, pNetAdapter );
}
// ISSUE-2002/20/28-stelo -not reading in LM Hosts setting
}
//----------------------------------------------------------------------------
//
// Function: ReadAdapterSpecificTcpipSettings
//
// Purpose: Reads network adapter specific TCP/IP settings and populates the
// pNetAdapter structure with their values.
//
// Arguments:
// IN HKEY hTcpipInterfaceKey - handle to the TCP/IP settings portion of
// the registry
// IN OUT NETWORK_ADAPTER_NODE *pNetAdapter - ptr to structure to load the
// TCP/IP values into
//
// Returns: VOID
//
//----------------------------------------------------------------------------
static VOIDReadAdapterSpecificTcpipSettings( IN HKEY hTcpipInterfaceKey, IN OUT NETWORK_ADAPTER_NODE *pNetAdapter ){
DWORD dwDHCP = 0; DWORD dwSize = 0; DWORD dwSize2 = 0; REGSAM SecurityAccess = KEY_QUERY_VALUE; HKEY hNetworkAdapterKey = NULL; LPTSTR lpszBuffer = NULL; LPTSTR lpszBuffer2 = NULL; TCHAR szStringGuid[MAX_GUID_STRING];
//
// Make sure we can allocate big enough buffers...
//
lpszBuffer = (LPTSTR) MALLOC( BUFFER_SIZE * sizeof(TCHAR) ); if ( !lpszBuffer ) { // Unable to allocate memory... bail!
return; } lpszBuffer2 = (LPTSTR) MALLOC( BUFFER_SIZE * sizeof(TCHAR) ); if ( !lpszBuffer2 ) { // Unable to allocate memory... bail!
FREE( lpszBuffer ); return; }
StringFromGUID2( pNetAdapter->guid, szStringGuid, StrBuffSize( szStringGuid ) );
if( RegOpenKeyEx( hTcpipInterfaceKey, szStringGuid, 0, SecurityAccess, &hNetworkAdapterKey ) == ERROR_SUCCESS ) {
dwSize = sizeof( dwDHCP );
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_ENABLE_DHCP, 0, NULL, (LPBYTE) &dwDHCP, &dwSize ) == ERROR_SUCCESS ) { if( dwDHCP == 1 ) {
pNetAdapter->bObtainIPAddressAutomatically = TRUE;
} else {
pNetAdapter->bObtainIPAddressAutomatically = FALSE;
}
}
if( ! pNetAdapter->bObtainIPAddressAutomatically ) { TCHAR *pszIpAddresses; TCHAR *pszSubnetAddresses; TCHAR *pszGatewayAddresses; TCHAR *pszDnsAddresses; TCHAR *pszWinsAddresses; TCHAR szWinsRegPath[MAX_INILINE_LEN + 1] = _T(""); HKEY hWinsKey = NULL; HRESULT hrCat;
dwSize = BUFFER_SIZE * sizeof(TCHAR); dwSize2 = BUFFER_SIZE * sizeof(TCHAR);
if( (RegQueryValueEx( hNetworkAdapterKey, REGVAL_IPADDRESS, 0, NULL, (LPBYTE) lpszBuffer, &dwSize ) == ERROR_SUCCESS) && (RegQueryValueEx( hNetworkAdapterKey, REGVAL_SUBNETMASK, 0, NULL, (LPBYTE) lpszBuffer2, &dwSize2 ) == ERROR_SUCCESS ) ) {
pszIpAddresses = lpszBuffer; // contains the IP Addresses
pszSubnetAddresses = lpszBuffer2; // contains the Subnet Masks
if( *pszIpAddresses != _T('\0') && *pszSubnetAddresses != _T('\0') ) {
//
// Add the IP and Subnet masks to their namelists
//
do {
TcpipAddNameToNameList( &pNetAdapter->Tcpip_IpAddresses, pszIpAddresses );
TcpipAddNameToNameList( &pNetAdapter->Tcpip_SubnetMaskAddresses, pszSubnetAddresses );
} while( GetNextIp( &pszIpAddresses ) && GetNextIp( &pszSubnetAddresses ) );
}
}
dwSize = BUFFER_SIZE * sizeof(TCHAR);
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_DEFAULTGATEWAY, 0, NULL, (LPBYTE) lpszBuffer, &dwSize ) == ERROR_SUCCESS ) {
pszGatewayAddresses = lpszBuffer; // contains the Gateway Addresses
if( *pszGatewayAddresses != _T('\0') ) {
//
// Add the Gateways to its namelist
//
do { AddNameToNameList( &pNetAdapter->Tcpip_GatewayAddresses, pszGatewayAddresses );
} while( GetNextIp( &pszGatewayAddresses ) );
}
}
//
// Get the DNS IPs
//
dwSize = BUFFER_SIZE * sizeof(TCHAR);
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_NAMESERVER, 0, NULL, (LPBYTE) lpszBuffer, &dwSize ) == ERROR_SUCCESS ) {
pszDnsAddresses = lpszBuffer; // Contains the DNS addresses
if( *pszDnsAddresses != _T('\0') ) {
TCHAR szDnsBuffer[MAX_INILINE_LEN + 1];
NetSettings.bObtainDNSServerAutomatically = FALSE;
//
// Loop grabbing the DNS IPs and inserting them into
// its namelist
//
while( GetCommaDelimitedEntry( szDnsBuffer, &pszDnsAddresses ) ) {
TcpipAddNameToNameList( &pNetAdapter->Tcpip_DnsAddresses, szDnsBuffer );
}
}
}
//
// Get the WINS server list
//
// Have to jump to different location in the registry to read
// the WINS data
//
//
// Build up the WINS registry path
//
lstrcpyn( szWinsRegPath, REGVAL_WINS, AS(szWinsRegPath) );
hrCat=StringCchCat( szWinsRegPath, AS(szWinsRegPath), szStringGuid );
//
// Grab all the WINS values from the registry
//
if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, szWinsRegPath, 0, SecurityAccess, &hWinsKey ) != ERROR_SUCCESS ) {
//
// need this key to read in the WINS values so bail if we
// can't get it
//
return;
}
dwSize = BUFFER_SIZE * sizeof(TCHAR);
if( RegQueryValueEx( hWinsKey, REGVAL_NAMESERVERLIST, NULL, NULL, (LPBYTE) lpszBuffer, &dwSize ) == ERROR_SUCCESS ) {
pszWinsAddresses = lpszBuffer;
if( *pszWinsAddresses != _T('\0') ) {
//
// Add the WINS IPs to the namelist
//
do {
AddNameToNameList( &pNetAdapter->Tcpip_WinsAddresses, pszWinsAddresses );
} while( GetNextIp( &pszWinsAddresses ) );
}
}
//
// Get the Domain
//
dwSize = BUFFER_SIZE * sizeof(TCHAR);
if( RegQueryValueEx( hNetworkAdapterKey, REGVAL_DOMAIN, 0, NULL, (LPBYTE) lpszBuffer, &dwSize ) == ERROR_SUCCESS ) {
lstrcpyn( pNetAdapter->szDNSDomainName, lpszBuffer, MAX_DNS_DOMAIN_LENGTH + 1 );
}
// ISSUE-2002/20/28-stelo- not reading the NetBiosOption
}
}
}
//----------------------------------------------------------------------------
//
// Function: GetNextIp
//
// Purpose: Gets the next string in a multi-NULL terminated string
//
// Arguments: TCHAR *ppszString - pointer to the current string
//
// Returns: BOOL - TRUE if ppszString points to the IP string
// FALSE if there are no more IP strings left
// TCHAR *ppszString - on TRUE, points to the next IP string
// - on FALSE, points to NULL
//
//----------------------------------------------------------------------------
static BOOL GetNextIp( IN OUT TCHAR **ppszString ){
while( **ppszString != _T('\0') ) { (*ppszString)++; }
//
// check that Char after the one we are currently looking at to see if it
// is the true end of the string(s)
//
if( *( (*ppszString) + 1 ) == _T('\0') ) { //
// 2 NULLs in a row signify there are no more IPs to read
//
return( FALSE );
} else { //
// Advance one more so we go past the \0 and point to the first char
// of the new IP address
//
(*ppszString)++;
return( TRUE );
}
}
//----------------------------------------------------------------------------
//
// Function: GetDomainMembershipInfo
//
// Purpose: Gets the domain/workgroup for the machine it is running on.
// Assumes enough space is already allocated in szName for the copy.
//
// Arguments: BOOL* bDomainMember - if TRUE, then the contents of szName is a Domain
// if FALSE, then the contents of szName is a Workgroup
//
// Returns: NTSTATUS - returns success or failure of the function
//
//----------------------------------------------------------------------------
static NTSTATUSGetDomainMembershipInfo( OUT BOOL* bDomainMember, OUT TCHAR *szName ){
NTSTATUS ntstatus; POLICY_PRIMARY_DOMAIN_INFO* ppdi; LSA_OBJECT_ATTRIBUTES loa; LSA_HANDLE hLsa = 0;
loa.Length = sizeof(LSA_OBJECT_ATTRIBUTES); loa.RootDirectory = NULL; loa.ObjectName = NULL; loa.Attributes = 0; loa.SecurityDescriptor = NULL; loa.SecurityQualityOfService = NULL;
ntstatus = LsaOpenPolicy( NULL, &loa, POLICY_VIEW_LOCAL_INFORMATION, &hLsa );
if( LSA_SUCCESS( ntstatus ) ) {
ntstatus = LsaQueryInformationPolicy( hLsa, PolicyPrimaryDomainInformation, (VOID **) &ppdi );
if( LSA_SUCCESS( ntstatus ) ) {
if( ppdi->Sid > 0 ) { *bDomainMember = TRUE; } else { *bDomainMember = FALSE; } lstrcpyn( szName, ppdi->Name.Buffer, AS(szName) );
}
LsaClose( hLsa );
} return( ntstatus );
}
//----------------------------------------------------------------------------
//
// Function: InitializeComInterface
//
// Purpose: Obtains the INetCfgClass interface and enumerates all the
// components. Handles cleanup of all interfaces if failure
// returned.
//
// Arguments:
// const GUID* pGuid - pointer to GUID representing the class of
// components represented by the returned pointer
// INetCfg* pNetCfg - pointer to initialized INetCfg interface
// INetCfgClass** ppNetCfgClass - output parameter pointing to
// the interface requested by the GUID
// IEnumNetCfgComponent *pEnum - output param that points to an
// IEnumNetCfgComponent to get to each individual INetCfgComponent
// INetCfgComponent *arrayComp[MAX_NUM_NET_COMPONENTS] - array of all
// the INetCfgComponents that correspond to the the given GUID
// ULONG* pCount - the number of INetCfgComponents in the array
//
// Returns: HRESULT - returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT InitializeComInterface( const GUID *pGuid, INetCfg *pNetCfg, INetCfgClass *pNetCfgClass, IEnumNetCfgComponent *pEnum, INetCfgComponent *arrayComp[MAX_NUM_NET_COMPONENTS], ULONG* pCount ){
HRESULT hr; HRESULT TempHr;
//
// Obtain the INetCfgClass interface pointer
//
hr = GetClass( pGuid, pNetCfg, &pNetCfgClass );
//
// Check validity of the pointer we got back from GetClass
//
TempHr = ChkInterfacePointer( pNetCfgClass, IID_INetCfgClass );
if( FAILED( hr ) || FAILED( TempHr ) ) {
ReleaseInterfaces( pNetCfg );
return( E_FAIL );
}
//
// Retrieve the enumerator interface
//
hr = pNetCfgClass->EnumComponents( &pEnum );
if( FAILED( hr ) || FAILED( ChkInterfacePointer( pEnum, IID_IEnumNetCfgComponent ) ) ) {
if( pNetCfgClass ) { pNetCfgClass->Release(); }
ReleaseInterfaces( pNetCfg );
return( E_FAIL );
}
hr = pEnum->Next( MAX_NUM_NET_COMPONENTS, &arrayComp[0], pCount );
if( FAILED( hr ) ) {
if( pEnum ) { pEnum->Release(); }
if( pNetCfgClass ) { pNetCfgClass->Release(); }
ReleaseInterfaces( pNetCfg );
return( E_FAIL );
}
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: UninitializeComInterface
//
// Purpose: To release the Net Config object interfaces.
//
// Arguments: INetCfgClass *pNetCfgClass - the INetCfgClass to be released
// IEnumNetCfgComponent *pEnum - the IEnumNetCfgComponent to be released
//
// Returns: VOID
//
//----------------------------------------------------------------------------
static VOID UninitializeComInterface( INetCfgClass *pNetCfgClass, IEnumNetCfgComponent *pEnum ) {
if( pNetCfgClass ) { pNetCfgClass->Release(); }
if( pEnum ) { pEnum->Release(); }
}
//----------------------------------------------------------------------------
//
// Function: InitializeInterfaces
//
// Purpose: Initializes COM, creates, and initializes the NetCfg
//
// Arguments: INetCfg** ppNetCfg - output param that is the created and
// initialized INetCfg interface
//
// Returns: HRESULT - returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT InitializeInterfaces( INetCfg** ppNetCfg ){
HRESULT hr = S_OK;
hr = CoInitializeEx( NULL, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE );
if( FAILED( hr ) ) { return( hr ); } hr = CreateAndInitNetCfg( ppNetCfg );
return( hr );
}
//----------------------------------------------------------------------------
//
// Function: CreateAndInitNetCfg
//
// Purpose: Instantiate and initalize an INetCfg interface
//
// Arguments: INetCfg** ppNetCfg - output parameter that is the initialized
// INetCfg interface
//
// Returns: HRESULT - returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULTCreateAndInitNetCfg( INetCfg** ppNetCfg ){
HRESULT hr = S_OK; INetCfg* pNetCfg = NULL;
if( ( ppNetCfg == NULL ) || IsBadWritePtr( ppNetCfg, sizeof(ppNetCfg) ) ) {
return( E_INVALIDARG );
}
*ppNetCfg = NULL;
hr = CoCreateInstance( CLSID_CNetCfg, NULL, CLSCTX_INPROC_SERVER, IID_INetCfg, reinterpret_cast<LPVOID*>(&pNetCfg) );
if( FAILED( hr ) ) { return( hr ); }
*ppNetCfg = pNetCfg;
//
// Initialize the INetCfg object.
//
hr = (*ppNetCfg)->Initialize( NULL );
if( FAILED( hr ) ) {
(*ppNetCfg)->Release(); CoUninitialize();
return( hr );
}
return( hr ); }
//----------------------------------------------------------------------------
//
// Function: ReleaseInterfaces
//
// Purpose: Uninitializes the NetCfg object and releases the interfaces
//
// Arguments: INetCfg* pNetCfg - the INetCfg interface to be released
//
// Returns: VOID
//
//----------------------------------------------------------------------------
static VOID ReleaseInterfaces( INetCfg* pNetCfg ){
HRESULT hr = S_OK;
//
// Check validity of the pNetCfg interface pointer
//
hr = ChkInterfacePointer( pNetCfg, IID_INetCfg );
if( FAILED( hr ) ) { return; }
if( pNetCfg != NULL ) { pNetCfg->Uninitialize();
pNetCfg->Release(); }
CoUninitialize();
return;
}
//----------------------------------------------------------------------------
//
// Function: ChkInterfacePointer
//
// Purpose: Checks if an interface pointer is valid and if it can query itself
//
// Arguments: IUnknown* pInterface - interface pointer to check
// REFIID IID_IInterface - the IID of parameter 1
//
// Returns: HRESULT - returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULT ChkInterfacePointer( IUnknown* pInterface, REFIID IID_IInterface ){
HRESULT hr = S_OK; IUnknown* pResInterface = NULL;
if( (pInterface == NULL) || IsBadReadPtr( pInterface, sizeof(pInterface) ) ) { hr = E_INVALIDARG;
return( hr ); }
hr = pInterface->QueryInterface( IID_IInterface, (void**)&pResInterface );
if( FAILED( hr ) ) { return( hr ); }
if( pInterface != pResInterface ) { hr = E_FAIL;
pResInterface->Release();
return( hr ); }
pResInterface->Release();
return( S_OK );
}
//----------------------------------------------------------------------------
//
// Function: GetClass
//
// Purpose: Retrieves INetCfgClass for the specified pGuid
//
// Arguments: const GUID* pGuid - pointer to GUID representing the class of
// components represented by the returned pointer
// INetCfg* pNetCfg - pointer to initialized INetCfg interface
// INetCfgClass** ppNetCfgClass - output parameter pointing to
// the interface requested by the GUID
//
// Returns: HRESULT - returns status of success or failure of the function
//
//----------------------------------------------------------------------------
static HRESULTGetClass( const GUID* pGuid, INetCfg* pNetCfg, INetCfgClass** ppNetCfgClass ){
HRESULT hr = S_OK; INetCfgClass* pNetCfgClass = NULL;
hr = ChkInterfacePointer( pNetCfg, IID_INetCfg );
if( FAILED( hr ) ) { return( E_INVALIDARG ); }
if( IsBadWritePtr( ppNetCfgClass, sizeof(ppNetCfgClass) ) ) { return( E_INVALIDARG ); }
hr = pNetCfg->QueryNetCfgClass( pGuid, IID_INetCfgClass, (void**)&pNetCfgClass );
if( FAILED( hr ) ) { return( hr ); }
*ppNetCfgClass = pNetCfgClass;
return( hr );
}
|
