windows-nt/Source/XPSP1/NT/net/wlbs/nlbmgr/wmibase/mipaddressadmin.cpp
2020-09-26 16:20:57 +08:00

593 lines
15 KiB
C++

// Copyright (c) Microsoft. All rights reserved.
//
// This is unpublished source code of Microsoft.
// The copyright notice above does not evidence any
// actual or intended publication of such source code.
// OneLiner : Implementation of MIPAddressAdmin
// DevUnit : wlbstest
// Author : Murtaza Hakim
// include files
#include "MIPAddressAdmin.h"
#include "MWmiParameter.h"
#include "Mtrace.h"
#include "NICCard.h"
#include <algorithm>
using namespace std;
// constructor for doing remotely.
//
MIPAddressAdmin::MIPAddressAdmin( const _bstr_t& machineIP,
const _bstr_t& nicName )
: _machineIP( machineIP ),
_nicName( nicName ),
machine( machineIP,
L"root\\cimv2",
NLBMGR_USERNAME,
NLBMGR_PASSWORD)
{
}
// constructor for doing things locally.
//
MIPAddressAdmin::MIPAddressAdmin( const _bstr_t& nicName )
: _machineIP( L"Not Set" ),
_nicName( nicName ),
machine( L"root\\cimv2" )
{
}
// copy constructor
//
MIPAddressAdmin::MIPAddressAdmin( const MIPAddressAdmin& obj )
: _machineIP( obj._machineIP ),
_nicName( obj._nicName ),
machine( obj.machine )
{
}
// assignment operator
//
MIPAddressAdmin&
MIPAddressAdmin::operator=(const MIPAddressAdmin& rhs )
{
_machineIP = rhs._machineIP;
_nicName = rhs._nicName;
machine = rhs.machine;
return *this;
}
// destructor
//
MIPAddressAdmin::~MIPAddressAdmin()
{
}
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::refreshConnection()
{
return status;
}
// addIPAddress
//
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::addIPAddress(const _bstr_t& ipAddrToAdd,
const _bstr_t& subnetMask)
{
// do basic verification.
//
// ensure that machine specified exists.
vector<MWmiInstance> nicInstance;
checkStatus( &nicInstance );
// get present ip addresses.
//
vector<_bstr_t> ipAddressStore;
vector<_bstr_t> subnetMaskStore;
bool dhcpEnabled;
isDHCPEnabled( dhcpEnabled );
if( dhcpEnabled == false )
{
getIPAddresses( &ipAddressStore,
&subnetMaskStore );
}
if( find( ipAddressStore.begin(),
ipAddressStore.end(),
ipAddrToAdd )
!= ipAddressStore.end() )
{
// the ip to add already exists.
// thus just return at this point.
return MIPAddressAdmin_SUCCESS;
}
ipAddressStore.push_back( ipAddrToAdd );
subnetMaskStore.push_back( subnetMask );
// form the safearray.
//
// array has one dimension.
//
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = ipAddressStore.size();
SAFEARRAY* psaIPAddress = SafeArrayCreate( VT_BSTR, 1, rgsabound );
SAFEARRAY* psaSubnetMask = SafeArrayCreate( VT_BSTR, 1, rgsabound );
long rgIndices;
HRESULT hr;
for( int i = 0; i < ipAddressStore.size(); ++i )
{
rgIndices = i;
hr = SafeArrayPutElement( psaIPAddress,
&rgIndices,
( wchar_t *) ipAddressStore[i]
);
hr = SafeArrayPutElement( psaSubnetMask,
&rgIndices,
( wchar_t *) subnetMaskStore[i]
);
}
// run enable static method.
VARIANT ipsV;
VARIANT ipaV;
VariantInit( &ipsV );
VariantInit( &ipaV );
ipaV.parray = psaIPAddress;
ipaV.vt = VT_ARRAY | VT_BSTR;
ipsV.parray = psaSubnetMask;
ipsV.vt = VT_ARRAY | VT_BSTR;
vector<MWmiParameter *> inputParameters;
MWmiParameter ipa(L"IPAddress");
ipa.setValue( ipaV );
inputParameters.push_back( &ipa );
MWmiParameter ips(L"SubnetMask");
ips.setValue( ipsV );
inputParameters.push_back( &ips );
// set output parameters
vector<MWmiParameter *> outputParameters;
MWmiParameter returnValue(L"ReturnValue");
outputParameters.push_back( &returnValue );
nicInstance[0].runMethod(L"EnableStatic",
inputParameters,
outputParameters );
VariantClear( &ipsV );
VariantClear( &ipaV );
// SafeArrayDestroy( psaIPAddress );
// SafeArrayDestroy( psaSubnetMask );
if( long( returnValue.getValue()) == 0 )
{
return MIPAddressAdmin_SUCCESS;
}
else
{
cout << "enablestatic has return " << long( returnValue.getValue() ) << endl;
#if DBG
WCHAR buf[256];
wsprintf(buf, L"EnableStatic failed with error 0x%08lx\n", long( returnValue.getValue() ) );
OutputDebugString(buf);
#endif // DBG
return COM_FAILURE;
}
}
// deleteIPAddress
//
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::deleteIPAddress(const _bstr_t& ipAddrToDelete )
{
// do basic verification.
//
// ensure that machine specified exists with nic.
vector<MWmiInstance> nicInstance;
checkStatus( &nicInstance );
// check if dhcp is enabled,
// if enabled we cannot delete anything
bool dhcpEnabled;
isDHCPEnabled( dhcpEnabled );
if( dhcpEnabled == true )
{
return NOT_SUPPORTED;
}
// get present ip addresses.
//
vector<_bstr_t> ipAddressStore;
vector<_bstr_t> subnetMaskStore;
getIPAddresses( &ipAddressStore,
&subnetMaskStore );
// check if ip address to delete exists.
//
vector<_bstr_t>::iterator posnToDelete;
posnToDelete = find( ipAddressStore.begin(),
ipAddressStore.end(),
ipAddrToDelete );
if( posnToDelete
== ipAddressStore.end() )
{
// the ip to delete does not exist.
return NO_SUCH_IP;
}
// remove this ip.
vector<_bstr_t> ipAddressNewStore;
vector<_bstr_t> subnetMaskNewStore;
bool ipAddrToDeleteFound = false;
for( int i = 0; i < ipAddressStore.size(); ++i )
{
if( ipAddressStore[i] == ipAddrToDelete )
{
ipAddrToDeleteFound = true;
}
else
{
ipAddressNewStore.push_back( ipAddressStore[i] );
subnetMaskNewStore.push_back( subnetMaskStore[i] );
}
}
if( ipAddrToDeleteFound == false )
{
// ip to delete does not exist on
// this nic.
return NO_SUCH_IP;
}
if( ipAddressNewStore.size() == 0 )
{
// the ip to remove is the last ip which exists.
// thus need to switch to dhcp.
//
return enableDHCP();
}
// form the safearray.
// array has one dimension.
//
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = ipAddressNewStore.size();
SAFEARRAY* psaIPAddress = SafeArrayCreate( VT_BSTR, 1, rgsabound );
SAFEARRAY* psaSubnetMask = SafeArrayCreate( VT_BSTR, 1, rgsabound );
long rgIndices[1];
HRESULT hr;
for( int i = 0; i < ipAddressNewStore.size(); ++i )
{
rgIndices[0] = i;
hr = SafeArrayPutElement( psaIPAddress,
rgIndices,
( wchar_t *) ipAddressNewStore[i]
);
hr = SafeArrayPutElement( psaSubnetMask,
rgIndices,
( wchar_t *) subnetMaskNewStore[i]
);
}
// run enable static method.
VARIANT ipsV;
VARIANT ipaV;
ipsV.parray = psaSubnetMask;
ipsV.vt = VT_ARRAY | VT_BSTR;
ipaV.parray = psaIPAddress;
ipaV.vt = VT_ARRAY | VT_BSTR;
vector<MWmiParameter *> inputParameters;
MWmiParameter ipa(L"IPAddress");
ipa.setValue( ipaV );
inputParameters.push_back( &ipa );
MWmiParameter ips(L"SubnetMask");
ips.setValue( ipsV );
inputParameters.push_back( &ips );
// set output parameters
vector<MWmiParameter *> outputParameters;
MWmiParameter returnValue(L"ReturnValue");
outputParameters.push_back( &returnValue );
nicInstance[0].runMethod(L"EnableStatic",
inputParameters,
outputParameters );
VariantClear( &ipsV );
VariantClear( &ipaV );
// SafeArrayDestroy( psaIPAddress );
// SafeArrayDestroy( psaSubnetMask );
if( long( returnValue.getValue()) == 0 )
{
return MIPAddressAdmin_SUCCESS;
}
else
{
cout << "enablestatic has return " << long( returnValue.getValue() ) << endl;
return COM_FAILURE;
}
return MIPAddressAdmin_SUCCESS;
}
// getIPAddresses
//
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::getIPAddresses( vector<_bstr_t>* ipAddress,
vector<_bstr_t>* subnetMask )
{
// do basic verification.
//
// ensure that machine specified exists.
vector<MWmiInstance> nicInstance;
checkStatus( &nicInstance );
// get the present values for ip address and subnet
//
vector<MWmiParameter* > parameterStore;
MWmiParameter ipsPresent(L"IPSubnet");
parameterStore.push_back( &ipsPresent );
MWmiParameter ipaPresent(L"IPAddress");
parameterStore.push_back( &ipaPresent );
nicInstance[0].getParameters( parameterStore );
_variant_t ipsT = ipsPresent.getValue();
VARIANT ipsV = ipsT.Detach();
_variant_t ipaT = ipaPresent.getValue();
VARIANT ipaV = ipaT.Detach();
if ( (ipsV.vt != (VT_ARRAY | VT_BSTR))
|| (ipaV.vt != (VT_ARRAY | VT_BSTR)))
{
// Ugh, let's pretend we didn't get anything.
goto end;
}
LONG count = ipsV.parray->rgsabound[0].cElements;
HRESULT hr;
BSTR* pbstr;
BSTR* pbstr1;
if( SUCCEEDED( SafeArrayAccessData( ipaV.parray, ( void **) &pbstr)))
{
hr = SafeArrayAccessData( ipsV.parray, (void **) &pbstr1 );
for( LONG x = 0; x < count; x++ )
{
ipAddress->push_back( _bstr_t( pbstr[x] ) );
subnetMask->push_back( _bstr_t( pbstr1[x] ) );
}
hr = SafeArrayUnaccessData( ipsV.parray );
hr = SafeArrayUnaccessData( ipaV.parray );
}
end:
VariantClear( &ipsV );
VariantClear( &ipaV );
return MIPAddressAdmin_SUCCESS;
}
// checkStatus
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::checkStatus( vector<MWmiInstance>* nicInstance )
{
_bstr_t temp;
if( _machineIP == _bstr_t( L"Not Set") )
{
NICCard::NICCard_Error errN;
vector< NICCard::Info > nicList;
errN = NICCard::getNics( &nicList );
if( errN != NICCard::NICCard_SUCCESS )
{
throw _com_error( WBEM_E_NOT_FOUND );
}
bool foundNic = false;
_bstr_t myguid;
for( int i = 0; i < nicList.size(); ++i )
{
if( _bstr_t( nicList[i].fullName.c_str() ) == _nicName )
{
// found nic
foundNic = true;
myguid = _bstr_t( nicList[i].guid.c_str() );
break;
}
}
if( foundNic == false )
{
throw _com_error( WBEM_E_NOT_FOUND );
}
vector< MWmiInstance > instanceStore;
machine.getInstances( L"Win32_NetworkAdapterConfiguration",
&instanceStore );
// set parameters to get.
vector<MWmiParameter* > parameterStore;
MWmiParameter SettingID(L"SettingID");
parameterStore.push_back( &SettingID );
for( int i = 0; i < instanceStore.size(); ++i )
{
instanceStore[i].getParameters( parameterStore );
temp = SettingID.getValue();
if( myguid == temp )
{
nicInstance->push_back( instanceStore[i] );
return MIPAddressAdmin_SUCCESS;
}
}
throw _com_error( WBEM_E_NOT_FOUND );
}
else
{
//
// ensure that the nic specified exists.
//
MWmiObject machineNlbsNic( _machineIP,
L"root\\microsoftnlb",
NLBMGR_USERNAME,
NLBMGR_PASSWORD);
vector< MWmiInstance > instanceStoreNlbsNic;
_bstr_t relPath =
L"NlbsNic.FullName=\"" + _nicName + "\"";
machineNlbsNic.getSpecificInstance( L"NlbsNic",
relPath,
&instanceStoreNlbsNic );
// set parameters to get.
vector<MWmiParameter* > parameterStoreNlbsNic;
MWmiParameter AdapterGuid(L"AdapterGuid");
parameterStoreNlbsNic.push_back( &AdapterGuid );
instanceStoreNlbsNic[0].getParameters( parameterStoreNlbsNic );
vector< MWmiInstance > instanceStore;
machine.getInstances( L"Win32_NetworkAdapterConfiguration",
&instanceStore );
// set parameters to get.
vector<MWmiParameter* > parameterStore;
MWmiParameter SettingID(L"SettingID");
parameterStore.push_back( &SettingID );
for( int i = 0; i < instanceStore.size(); ++i )
{
instanceStore[i].getParameters( parameterStore );
temp = SettingID.getValue();
if( _bstr_t( AdapterGuid.getValue() ) == temp )
{
nicInstance->push_back( instanceStore[i] );
return MIPAddressAdmin_SUCCESS;
}
}
throw _com_error( WBEM_E_NOT_FOUND );
}
}
// isDHCPEnabled
//
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::isDHCPEnabled( bool& dhcpEnabled )
{
// do basic verification.
//
// ensure that machine specified exists.
vector<MWmiInstance> nicInstance;
checkStatus( &nicInstance );
// get the present value for DHCPEnabled
//
vector<MWmiParameter* > parameterStore;
MWmiParameter DHCPEnabled( L"DHCPEnabled" );
parameterStore.push_back( &DHCPEnabled );
nicInstance[0].getParameters( parameterStore );
dhcpEnabled = DHCPEnabled.getValue();
return MIPAddressAdmin_SUCCESS;
}
// enableDHCP
//
MIPAddressAdmin::MIPAddressAdmin_Error
MIPAddressAdmin::enableDHCP()
{
// do basic verification.
//
// ensure that machine specified exists.
vector<MWmiInstance> nicInstance;
checkStatus( &nicInstance );
bool dhcpEnabled;
isDHCPEnabled( dhcpEnabled );
if( dhcpEnabled == true )
{
// dhcp is already enabled.
return MIPAddressAdmin_SUCCESS;
}
// set input parameters.
// no input parameters.
vector<MWmiParameter *> inputParameters;
// set output parameters
vector<MWmiParameter *> outputParameters;
MWmiParameter returnValue(L"ReturnValue");
outputParameters.push_back( &returnValue );
nicInstance[0].runMethod(L"EnableDHCP",
inputParameters,
outputParameters );
if( long ( returnValue.getValue() ) == 0 )
{
return MIPAddressAdmin_SUCCESS;
}
else
{
cout << "enablestatic has return " << long( returnValue.getValue() ) << endl;
return COM_FAILURE;
}
}