593 lines
15 KiB
C++
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;
|
|
}
|
|
}
|
|
|