windows-xp/Source/XPSP1/NT/net/wlbs/nlbmgr/nlbsprov/mnlbmachine.cpp

// 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 MNLBMachine
// DevUnit   :  wlbstest
// Author    :  Murtaza Hakim

// History:
// --------
// 
// Revised by : mhakim
// Date       : 02-09-01
// Reason     : clustersetting class no longer has igmpjoininterval
//              property.
//
// Revised by : mhakim
// Date       : 02-14-01
// Reason     : The order in which win2k and whistler settings
//              is done depends on previous state of cluster.

// include files
#include "MNLBMachine.h"
#include "MNLBExe.h"

#include "MTrace.h"
#include "MNicInfo.h"
#include "WTokens.h"

#include <iostream>

using namespace std;

// constructor
//
MNLBMachine::MNLBMachine( const _bstr_t&    ip,
                          const _bstr_t&    clusterIP )
        : mIP( ip ),
          mClusterIP( clusterIP ),
          p_machine( 0 )
{
    connectToMachine();
    TRACE(MTrace::INFO, L"mnlbmachine constructor\n");
}

// constructor for local machine
//
MNLBMachine::MNLBMachine( const _bstr_t&    clusterIP )
        : mIP( L"self" ),
          mClusterIP( clusterIP ), 
          p_machine( 0 )
{
    connectToMachine();
    TRACE(MTrace::INFO, L"mnlbmachine constructor\n");
}


// default constructor
// 
// note that default constructor is purposely left undefined.  
// NO one should be using it.  It is declared just for vector class usage.


// copy constructor
//
MNLBMachine::MNLBMachine(const MNLBMachine& objToCopy )
        : mIP( objToCopy.mIP ),
          mClusterIP( objToCopy.mClusterIP ),
          p_machine( auto_ptr<MWmiObject>( new MWmiObject( *objToCopy.p_machine ) ) )
{
    TRACE(MTrace::INFO, L"mnlbsmachine copy constructor\n");
}


// assignment operator
//
MNLBMachine&
MNLBMachine::operator=( const MNLBMachine& rhs )
{
    mIP = rhs.mIP;
    mClusterIP = rhs.mClusterIP;
    p_machine = auto_ptr<MWmiObject>( new MWmiObject( *rhs.p_machine ) );

    TRACE(MTrace::INFO, L"mnlbsmachine assignment operator\n");

    return *this;
}


// destructor
//
MNLBMachine::~MNLBMachine()
{
    TRACE(MTrace::INFO, L"mnlbsmachine destructor\n");
}

// getClusterProperties
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getClusterProperties( ClusterProperties* cp )
{
    // set parameters to get for win2k
    //
    vector<MWmiParameter* >   parameterStoreWin2k;

    MWmiParameter ClusterIPAddress(L"ClusterIPAddress");
    parameterStoreWin2k.push_back( &ClusterIPAddress );

    MWmiParameter ClusterNetworkMask(L"ClusterNetworkMask");
    parameterStoreWin2k.push_back( &ClusterNetworkMask );

    MWmiParameter ClusterName(L"ClusterName");
    parameterStoreWin2k.push_back( &ClusterName );

    MWmiParameter ClusteMACAddress(L"ClusterMACAddress");
    parameterStoreWin2k.push_back( &ClusteMACAddress );

    MWmiParameter MulticastSupportEnabled(L"MulticastSupportEnabled");
    parameterStoreWin2k.push_back( &MulticastSupportEnabled );

    MWmiParameter RemoteControlEnabled(L"RemoteControlEnabled");
    parameterStoreWin2k.push_back( &RemoteControlEnabled );

    // set parameters to get for whistler
    // these properties only present in whistler.
    //
    vector<MWmiParameter* >   parameterStoreWhistler;

    MWmiParameter IgmpSupport(L"IgmpSupport");
    parameterStoreWhistler.push_back( &IgmpSupport );

    MWmiParameter ClusterIPToMulticastIP(L"ClusterIPToMulticastIP");
    parameterStoreWhistler.push_back( &ClusterIPToMulticastIP );

    MWmiParameter MulticastIPAddress(L"MulticastIPAddress");
    parameterStoreWhistler.push_back( &MulticastIPAddress );

    // Edited( mhakim 02-09-01)
    // now no longer do we have any igmpjoininterval property.
    // 

    // MWmiParameter IgmpJoinInterval(L"IgmpJoinInterval");
    // parameterStoreWhistler.push_back( &IgmpJoinInterval );


    // get instances of clustersetting class.    
    //
    vector< MWmiInstance >    instanceStore;

    _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
        
    p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting",
                                    relPath,
                                    &instanceStore );

    // get win2k parameters
    instanceStore[0].getParameters( parameterStoreWin2k );

    // get whistler parameters
    bool machineIsWhistler = true;

    try
    {
        // this will fail on win2k
        // as adapterguid, igmpsupport etc are not present.
        instanceStore[0].getParameters( parameterStoreWhistler );
    }
    catch( _com_error e )
    {
        // maybe it was a win2k machine.  This exception is expected, thus catch.
        // for better safety, need to find exact error code returned and then only do the 
        // folllowing otherwise need to rethrow.
        //
        TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n");
        machineIsWhistler = false;
    }

    cp->cIP = ClusterIPAddress.getValue();
    
    cp->cSubnetMask = ClusterNetworkMask.getValue();
            
    cp->cFullInternetName = ClusterName.getValue();
            
    cp->cNetworkAddress = ClusteMACAddress.getValue();
            
    cp->multicastSupportEnabled = MulticastSupportEnabled.getValue();
        
    cp->remoteControlEnabled  = RemoteControlEnabled.getValue();

    if( machineIsWhistler == true )
    {
        cp->igmpSupportEnabled = IgmpSupport.getValue();
                
        cp->clusterIPToMulticastIP = ClusterIPToMulticastIP.getValue();

        cp->multicastIPAddress = MulticastIPAddress.getValue();

        // Edited( mhakim 02-09-01)
        // now no longer do we have any igmpjoininterval property.
        // 

        // cp->igmpJoinInterval = IgmpJoinInterval.getValue();
    }

    return MNLBMachine_SUCCESS;
}    

// getHostProperties
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getHostProperties( HostProperties* hp )
{
    // get node properties
    //
    vector<MWmiParameter* >    parameterStoreWin2k;

    // the status code is to be got from the Node class.
    //
    MWmiParameter  StatusCode(L"StatusCode");
    parameterStoreWin2k.push_back( &StatusCode );    

    vector< MWmiInstance >    instanceStore;

    _bstr_t relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + mHostID + L"\"";

    p_machine->getSpecificInstance( L"MicrosoftNLB_Node",
                                    relPath,
                                    &instanceStore );
    instanceStore[0].getParameters( parameterStoreWin2k );

    hp->hostStatus = long( StatusCode.getValue() );

    parameterStoreWin2k.erase( parameterStoreWin2k.begin(), parameterStoreWin2k.end() );

    instanceStore.erase( instanceStore.begin(), instanceStore.end() );
    
    MWmiParameter  DedicatedIPAddress(L"DedicatedIPAddress");
    parameterStoreWin2k.push_back( &DedicatedIPAddress );

    MWmiParameter  DedicatedNetworkMask(L"DedicatedNetworkMask");
    parameterStoreWin2k.push_back( &DedicatedNetworkMask );

    MWmiParameter  HostPriority(L"HostPriority");
    parameterStoreWin2k.push_back( &HostPriority );

    MWmiParameter  ClusterModeOnStart(L"ClusterModeOnStart");
    parameterStoreWin2k.push_back( &ClusterModeOnStart );

    MWmiParameter Server("__Server");
    parameterStoreWin2k.push_back( &Server);

    // set parameters to get for whistler
    // these properties only present in whistler.
    //
    vector<MWmiParameter* >   parameterStoreWhistler;

    MWmiParameter AdapterGuid(L"AdapterGuid");
    parameterStoreWhistler.push_back( &AdapterGuid );


    // get instances of nodesetting class.
    //
    relPath = L"MicrosoftNLB_NodeSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
    p_machine->getSpecificInstance( L"MicrosoftNLB_NodeSetting",
                                    relPath,
                                    &instanceStore );

    // get win2k parameters.
    instanceStore[0].getParameters( parameterStoreWin2k );

    // get whistler parameters
    bool machineIsWhistler = true;

    try
    {
        // this will fail on win2k
        // as adapterguid, igmpsupport etc are not present.
        instanceStore[0].getParameters( parameterStoreWhistler );
    }
    catch( _com_error e )
    {
        // maybe it was a win2k machine.  This exception is expected, thus catch.
        // for better safety, need to find exact error code returned and then only do the 
        // folllowing otherwise need to rethrow.
        //
        TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n");
        machineIsWhistler = false;
    }


    hp->hIP = DedicatedIPAddress.getValue();

    hp->hSubnetMask = DedicatedNetworkMask.getValue();
            
    hp->hID         = HostPriority.getValue();
            
    hp->initialClusterStateActive = ClusterModeOnStart.getValue();

    hp->machineName = Server.getValue();

    if( machineIsWhistler == true )
    {
        Common::getNLBNicInfoForWhistler( mIP,
                                          _bstr_t( AdapterGuid.getValue() ), 
                                          hp->nicInfo );
    }
    else
    {
        Common::getNLBNicInfoForWin2k(  mIP,
                                        hp->nicInfo );
    }

    return MNLBMachine_SUCCESS;
}


// setClusterProperties    
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::setClusterProperties( const ClusterProperties& cp,
                                    unsigned long* retVal 
                                    )
{
    // set parameters to set for win2k
    vector<MWmiParameter* >   parameterStoreWin2k;

    MWmiParameter ClusterIPAddress(L"ClusterIPAddress");
    ClusterIPAddress.setValue( cp.cIP );
    parameterStoreWin2k.push_back( &ClusterIPAddress );
    

    MWmiParameter ClusterNetworkMask(L"ClusterNetworkMask");
    ClusterNetworkMask.setValue( cp.cSubnetMask );
    parameterStoreWin2k.push_back( &ClusterNetworkMask );

    MWmiParameter ClusterName(L"ClusterName");
    ClusterName.setValue( cp.cFullInternetName );
    parameterStoreWin2k.push_back( &ClusterName );

    // mac address cannot be set.

    MWmiParameter MulticastSupportEnabled(L"MulticastSupportEnabled");
    MulticastSupportEnabled.setValue( cp.multicastSupportEnabled );
    parameterStoreWin2k.push_back( &MulticastSupportEnabled );

    MWmiParameter RemoteControlEnabled(L"RemoteControlEnabled");
    RemoteControlEnabled.setValue( cp.remoteControlEnabled );
    parameterStoreWin2k.push_back( &RemoteControlEnabled );

    // set parameters for whistler.
    // these properties only for whistler
    vector<MWmiParameter* >   parameterStoreWhistler;

    MWmiParameter IgmpSupport(L"IgmpSupport");
    IgmpSupport.setValue( cp.igmpSupportEnabled );
    parameterStoreWhistler.push_back( &IgmpSupport );

    MWmiParameter ClusterIPToMulticastIP(L"ClusterIPToMulticastIP");
    ClusterIPToMulticastIP.setValue( cp.clusterIPToMulticastIP );
    parameterStoreWhistler.push_back( &ClusterIPToMulticastIP );

    MWmiParameter MulticastIPAddress(L"MulticastIPAddress");
    MulticastIPAddress.setValue( cp.multicastIPAddress );
    parameterStoreWhistler.push_back( &MulticastIPAddress );

    // Edited( mhakim 02-09-01)
    // now no longer do we have any igmpjoininterval property.
    // 

    // MWmiParameter IgmpJoinInterval(L"IgmpJoinInterval");
    // IgmpJoinInterval.setValue( cp.igmpJoinInterval );
    // parameterStoreWhistler.push_back( &IgmpJoinInterval );

    vector< MWmiInstance >    instanceStore;

    _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
    p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting",
                                    relPath,
                                    &instanceStore );

    // Edited( mhakim 02-14-01)
    //
    // The order in which win2k and whistler operations
    // need to be done depends on previous state of cluster.
    // If the previous mode of cluster was unicast, then
    // you have to do win2k first, whistler next.
    // If the previous mode was mcast+igmp you have to 
    // do whistler first, win2k next.
    // If the previous mode was mcast, the order does not
    // matter.
    // All this is because you cant have unicast+igmp 
    // together.

    // find previous cluster mode.
    ClusterProperties cpPrevious;
    getClusterProperties( &cpPrevious );

    if( cpPrevious.multicastSupportEnabled == false ) 
    {
        // mode is unicast

        // set win2k parameters.
        instanceStore[0].setParameters( parameterStoreWin2k );
        
        // set whistler parameters.
        try
        {
            instanceStore[0].setParameters( parameterStoreWhistler );
        }
        catch( _com_error e )
        {
            // maybe it was a win2k machine.  This exception is expected, thus catch.
            // For better safety, need to match error code returned with expected and then only do the 
            // folllowing otherwise need to rethrow.
            //
            TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n");
        }
    }
    else
    {
        // set whistler parameters.
        try
        {
            instanceStore[0].setParameters( parameterStoreWhistler );
        }
        catch( _com_error e )
        {
            // maybe it was a win2k machine.  This exception is expected, thus catch.
            // For better safety, need to match error code returned with expected and then only do the 
            // folllowing otherwise need to rethrow.
            //
            TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n");
        }

        // set win2k parameters.
        instanceStore[0].setParameters( parameterStoreWin2k );
    }

    // sync up the driver with these changes.
    reload( retVal );

    mClusterIP = cp.cIP;

    return MNLBMachine_SUCCESS;
}


// setHostProperties
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::setHostProperties( const HostProperties& hp,
                                 unsigned long* retVal )
{
    // set node properties
    //
    vector<MWmiParameter* >    parameterStore;
    
    MWmiParameter  DedicatedIPAddress(L"DedicatedIPAddress");
    DedicatedIPAddress.setValue( hp.hIP );
    parameterStore.push_back( &DedicatedIPAddress );

    MWmiParameter  DedicatedNetworkMask(L"DedicatedNetworkMask");
    DedicatedNetworkMask.setValue( hp.hSubnetMask );
    parameterStore.push_back( &DedicatedNetworkMask );

    MWmiParameter  HostPriority(L"HostPriority");
    HostPriority.setValue( hp.hID );
    parameterStore.push_back( &HostPriority );

    MWmiParameter  ClusterModeOnStart(L"ClusterModeOnStart");
    ClusterModeOnStart.setValue( hp.initialClusterStateActive );
    parameterStore.push_back( &ClusterModeOnStart );

    // get instances of nodesetting class.
    //
    vector< MWmiInstance >     instanceStore;

    _bstr_t relPath = L"MicrosoftNLB_NodeSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
    p_machine->getSpecificInstance( L"MicrosoftNLB_NodeSetting",
                                    relPath,
                                    &instanceStore );

    instanceStore[0].setParameters( parameterStore );

    // convert hp.hID into string
    wchar_t hIDString[Common::BUF_SIZE];

    swprintf( hIDString, L"%d", hp.hID );
    
    // sync up the driver with these changes.
    reload( retVal );


    mHostID = hIDString;

    return MNLBMachine_SUCCESS;
}

// getPortRulesLoadBalanced
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesLoadBalanced( vector<MNLBPortRuleLoadBalanced>* portsLB )
{
    vector<MWmiInstance> instanceStore;

    return getPortRulesLoadBalanced_private( portsLB, 
                                             &instanceStore );

}

// getPortRulesLoadBalanced_private
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesLoadBalanced_private( vector<MNLBPortRuleLoadBalanced>* portsLB,
                                                vector<MWmiInstance>*          instances )
{
    _bstr_t myName = mClusterIP + L":" + mHostID;

    // get port properties.
    //
    vector<MWmiParameter* >    parameterStore;

    MWmiParameter   Name(L"Name");
    parameterStore.push_back( &Name );

    MWmiParameter   StartPort(L"StartPort");
    parameterStore.push_back( &StartPort );

    MWmiParameter EndPort(L"EndPort");
    parameterStore.push_back( &EndPort );

    MWmiParameter ProtocolProp(L"Protocol");
    parameterStore.push_back( &ProtocolProp );

    MWmiParameter EqualLoad(L"EqualLoad");
    parameterStore.push_back( &EqualLoad );

    MWmiParameter LoadWeight(L"LoadWeight");
    parameterStore.push_back( &LoadWeight );

    MWmiParameter AffinityProp(L"Affinity");
    parameterStore.push_back( &AffinityProp );    

    MNLBPortRule::Affinity    affinity;
    MNLBPortRule::Protocol    trafficToHandle;

    p_machine->getInstances( L"MicrosoftNLB_PortRuleLoadBalanced",
                             instances );
    for( int i = 0; i < instances->size(); ++i )
    {
        (*instances)[i].getParameters( parameterStore );
            
        if( _bstr_t( Name.getValue() ) != myName )
        {
            // this portrule is not for this cluster
            continue;
        }

        switch( long (ProtocolProp.getValue()) )
        {
            case 1:
                trafficToHandle = MNLBPortRule::tcp;
                break;

            case 2:
                trafficToHandle = MNLBPortRule::udp;
                break;

            case 3:
                trafficToHandle = MNLBPortRule::both;
                break;

            default:
                // bug.
                TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
                throw _com_error( WBEM_E_UNEXPECTED );
                break;
        }


        switch(  long(AffinityProp.getValue()) )
        {
            case 0:
                affinity = MNLBPortRule::none;
                break;

            case 1:
                affinity = MNLBPortRule::single;
                break;

            case 2:
                affinity = MNLBPortRule::classC;
                break;

            default:
                // bug.
                TRACE( MTrace::SEVERE_ERROR, "unidentified affinity\n" );
                throw _com_error( WBEM_E_UNEXPECTED );
                break;
        }

                
        portsLB->push_back( MNLBPortRuleLoadBalanced(long (StartPort.getValue()),
                                                  long( EndPort.getValue()),
                                                  trafficToHandle,
                                                  bool( EqualLoad.getValue()),
                                                  long( LoadWeight.getValue()),
                                                  affinity) );
                                
    }

    return MNLBMachine_SUCCESS;
}


// getPortRulesFailover
//       
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesFailover( vector<MNLBPortRuleFailover>* portsF )
{
    vector<MWmiInstance> instanceStore;

    return getPortRulesFailover_private( portsF, 
                                         &instanceStore );
}
    

// getPortRulesFailover_private
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesFailover_private( vector<MNLBPortRuleFailover>* portsF,
                                            vector<MWmiInstance>*          instances )
{    
    _bstr_t myName = mClusterIP + L":" + mHostID;

    // get port properties.
    //
    vector<MWmiParameter* >    parameterStore;

    MWmiParameter   Name(L"Name");
    parameterStore.push_back( &Name );

    MWmiParameter   StartPort(L"StartPort");
    parameterStore.push_back( &StartPort );

    MWmiParameter EndPort(L"EndPort");
    parameterStore.push_back( &EndPort );

    MWmiParameter ProtocolProp(L"Protocol");
    parameterStore.push_back( &ProtocolProp );

    MWmiParameter Priority(L"Priority");
    parameterStore.push_back( &Priority );

    MNLBPortRule::Protocol    trafficToHandle;

    p_machine->getInstances( L"MicrosoftNLB_PortRuleFailover",
                             instances );

    for( int i = 0; i < instances->size(); ++i )
    {
        (*instances)[i].getParameters( parameterStore );
            
        if( _bstr_t( Name.getValue() ) != myName )
        {
            // this portrule is not for this cluster
            continue;
        }

        switch( long (ProtocolProp.getValue()) )
        {
            case 1:
                trafficToHandle = MNLBPortRule::tcp;
                break;

            case 2:
                trafficToHandle = MNLBPortRule::udp;
                break;

            case 3:
                trafficToHandle = MNLBPortRule::both;
                break;

            default:
                // bug.
                TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
                throw _com_error( WBEM_E_UNEXPECTED );
                break;
        }

        portsF->push_back( MNLBPortRuleFailover(long (StartPort.getValue()),
                                             long( EndPort.getValue()),
                                             trafficToHandle,
                                             long( Priority.getValue()) )
                           );
    }

    return MNLBMachine_SUCCESS;
}


// getPortRulesDisabled
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesDisabled( vector<MNLBPortRuleDisabled>* portsD )
{

    vector<MWmiInstance> instanceStore;

    return getPortRulesDisabled_private( portsD, 
                                         &instanceStore );

}    


// getPortRulesDisabled_private
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPortRulesDisabled_private( vector<MNLBPortRuleDisabled>*         portsD,
                                            vector<MWmiInstance>*          instances )
{
    _bstr_t myName = mClusterIP + L":" + mHostID;

    // get port properties.
    //
    vector<MWmiParameter* >    parameterStore;

    MWmiParameter   Name(L"Name");
    parameterStore.push_back( &Name );

    MWmiParameter   StartPort(L"StartPort");
    parameterStore.push_back( &StartPort );

    MWmiParameter EndPort(L"EndPort");
    parameterStore.push_back( &EndPort );

    MWmiParameter ProtocolProp(L"Protocol");
    parameterStore.push_back( &ProtocolProp );

    MNLBPortRule::Protocol    trafficToHandle;

    p_machine->getInstances( L"MicrosoftNLB_PortRuleDisabled",
                             instances );
    for( int i = 0; i < instances->size(); ++i )
    {
        (*instances)[i].getParameters( parameterStore );
            
        if( _bstr_t( Name.getValue() ) != myName )
        {
            // this portrule is not for this cluster
            continue;
        }

        switch( long (ProtocolProp.getValue()) )
        {
            case 1:
                trafficToHandle = MNLBPortRule::tcp;
                break;

            case 2:
                trafficToHandle = MNLBPortRule::udp;
                break;

            case 3:
                trafficToHandle = MNLBPortRule::both;
                break;

            default:
                // bug.
                TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
                throw _com_error( WBEM_E_UNEXPECTED );
                break;
        }

        portsD->push_back( MNLBPortRuleDisabled( long (StartPort.getValue() ),
                                              long( EndPort.getValue() ),
                                              trafficToHandle ) );
    }

    return MNLBMachine_SUCCESS;
}


// addPortRuleLoadBalanced
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::addPortRuleLoadBalanced( const MNLBPortRuleLoadBalanced& portRuleLB )
{

    // set the name as "clusterip:hostid"
    _bstr_t str;
    str = mClusterIP + L":" + mHostID;

    vector<MWmiParameter *> instanceParameter;

    MWmiParameter  name(L"Name");
    name.setValue( str );
    instanceParameter.push_back( &name );

    MWmiParameter  sp(L"StartPort");
    sp.setValue( portRuleLB._startPort );
    instanceParameter.push_back( &sp );

    MWmiParameter  EndPort(L"EndPort");
    EndPort.setValue( portRuleLB._endPort );
    instanceParameter.push_back( &EndPort );

    long protocolValue;
    MWmiParameter  protocol(L"Protocol");
    switch( portRuleLB._trafficToHandle )
    {
        case MNLBPortRule::both:
            protocolValue = 3;
            protocol.setValue( protocolValue );
            break;
            
        case MNLBPortRule::tcp:
            protocolValue = 1;
            protocol.setValue( protocolValue );
            break;

        case MNLBPortRule::udp:
            protocolValue = 2;
            protocol.setValue( protocolValue );
            break;
                    
        default:
            // bug.
            TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
            throw _com_error( WBEM_E_UNEXPECTED );
            break;
    }

    instanceParameter.push_back( &protocol );

    MWmiParameter  el(L"EqualLoad");
    el.setValue( portRuleLB._isEqualLoadBalanced );
    instanceParameter.push_back( &el );    

    MWmiParameter  lw(L"LoadWeight");
    lw.setValue( portRuleLB._load );
    instanceParameter.push_back( &lw );    

    MWmiParameter  affinity(L"Affinity");
    long affinityValue;
    switch(  portRuleLB._affinity )
    {
        case MNLBPortRule::none:
            affinityValue = 0;
            affinity.setValue(affinityValue);
            break;

        case MNLBPortRule::single:
            affinityValue = 1;
            affinity.setValue(affinityValue);
            break;

        case MNLBPortRule::classC:
            affinityValue = 2;
            affinity.setValue(affinityValue);
            break;

        default:
            // bug.
            TRACE( MTrace::SEVERE_ERROR, "unidentified affinity\n" );
            throw _com_error( WBEM_E_UNEXPECTED );
            break;
    }
    instanceParameter.push_back( &affinity );    

    p_machine->createInstance( L"MicrosoftNLB_PortRuleLoadBalanced",
                               instanceParameter
                               );
    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}

// addPortRuleFailover
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::addPortRuleFailover( const MNLBPortRuleFailover& portRuleF )
{

    // set the name as "clusterip:hostid"
    _bstr_t str;
    str = mClusterIP + L":" + mHostID;

    vector<MWmiParameter *> instanceParameter;

    MWmiParameter  name(L"Name");
    name.setValue( str );
    instanceParameter.push_back( &name );

    MWmiParameter  sp(L"StartPort");
    sp.setValue( portRuleF._startPort );
    instanceParameter.push_back( &sp );

    MWmiParameter  EndPort(L"EndPort");
    EndPort.setValue( portRuleF._endPort );
    instanceParameter.push_back( &EndPort );

    long protocolValue;
    MWmiParameter  protocol(L"Protocol");
    switch( portRuleF._trafficToHandle )
    {
        case MNLBPortRule::both:
            protocolValue = 3;
            protocol.setValue( protocolValue );
            break;
            
        case MNLBPortRule::tcp:
            protocolValue = 1;
            protocol.setValue( protocolValue );
            break;

        case MNLBPortRule::udp:
            protocolValue = 2;
            protocol.setValue( protocolValue );
            break;
                    
        default:
            TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
            throw _com_error( WBEM_E_UNEXPECTED );
            break;
    }
    instanceParameter.push_back( &protocol );

    MWmiParameter p("Priority");
    p.setValue( portRuleF._priority);
    instanceParameter.push_back( &p );

    p_machine->createInstance( L"MicrosoftNLB_PortRuleFailover",
                               instanceParameter
                               );

    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}


// addPortRuleDisabled
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::addPortRuleDisabled( const MNLBPortRuleDisabled& portRuleD )
{

    // set the name as "clusterip:hostid"
    _bstr_t str;
    str = mClusterIP + L":" + mHostID;

    vector<MWmiParameter *> instanceParameter;

    MWmiParameter  name(L"Name");
    name.setValue( str );
    instanceParameter.push_back( &name );

    MWmiParameter  sp(L"StartPort");
    sp.setValue( portRuleD._startPort );
    instanceParameter.push_back( &sp );

    MWmiParameter  ep(L"EndPort");
    ep.setValue( portRuleD._endPort );
    instanceParameter.push_back( &ep );

    long protocolValue;
    MWmiParameter  protocol(L"Protocol");
    switch( portRuleD._trafficToHandle )
    {
        case MNLBPortRule::both:
            protocolValue = 3;
            protocol.setValue( protocolValue );
            break;
            
        case MNLBPortRule::tcp:
            protocolValue = 1;
            protocol.setValue( protocolValue );
            break;

        case MNLBPortRule::udp:
            protocolValue = 2;
            protocol.setValue( protocolValue );
            break;
                    
        default:
            // bug.
            TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" );
            throw _com_error( WBEM_E_UNEXPECTED );
            break;
    }
    instanceParameter.push_back( &protocol );

    p_machine->createInstance( L"MicrosoftNLB_PortRuleDisabled",
                               instanceParameter
                               );

    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}

// removePortRuleLoadBalanced
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::removePortRuleLoadBalanced( const MNLBPortRuleLoadBalanced& portRuleLB )
{

    _bstr_t myName = mClusterIP + L":" + mHostID;

    wchar_t startPortBuffer[Common::BUF_SIZE];

    swprintf( startPortBuffer, L"%d", portRuleLB._startPort );

    vector<MWmiInstance >           instanceStorePortRuleLoadBalanced;
    _bstr_t relPath = L"MicrosoftNLB_PortRuleLoadBalanced.Name=\""  
        + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer;


    p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleLoadBalanced",
                                    relPath,
                                    &instanceStorePortRuleLoadBalanced );

    p_machine->deleteInstance( instanceStorePortRuleLoadBalanced[0] );

    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}


// removePortRuleFailover
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::removePortRuleFailover( const MNLBPortRuleFailover& portRuleF )
{
    _bstr_t myName = mClusterIP + L":" + mHostID;

    wchar_t startPortBuffer[Common::BUF_SIZE];

    swprintf( startPortBuffer, L"%d", portRuleF._startPort );

    vector<MWmiInstance >           instanceStorePortRuleFailover;
    _bstr_t relPath = L"MicrosoftNLB_PortRuleFailover.Name=\""  
        + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer;


    p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleFailover",
                                    relPath,
                                    &instanceStorePortRuleFailover );

    p_machine->deleteInstance( instanceStorePortRuleFailover[0] );

    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}

// removePortRuleDisabled
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::removePortRuleDisabled( const MNLBPortRuleDisabled& portRuleD )
{

    _bstr_t myName = mClusterIP + L":" + mHostID;

    wchar_t startPortBuffer[Common::BUF_SIZE];

    swprintf( startPortBuffer, L"%d", portRuleD._startPort );

    vector<MWmiInstance >           instanceStorePortRuleDisabled;
    _bstr_t relPath = L"MicrosoftNLB_PortRuleDisabled.Name=\""  
        + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer;


    p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleDisabled",
                                    relPath,
                                    &instanceStorePortRuleDisabled );

    p_machine->deleteInstance( instanceStorePortRuleDisabled[0] );

    // sync up the driver with these changes.
    unsigned long retVal;
    reload( &retVal );

    return MNLBMachine_SUCCESS;
}




// start
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::start( int hostID, unsigned long* retVal )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;
    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::start( instanceStore[0], retVal );

    return MNLBMachine_SUCCESS;
}



// stop
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::stop( int hostID, unsigned long* retVal )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;
    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::stop( instanceStore[0], retVal );

    return MNLBMachine_SUCCESS;
}


// resume
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::resume( int hostID, unsigned long* retVal )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;
    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::resume( instanceStore[0], retVal );

    return MNLBMachine_SUCCESS;
}


// suspend
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::suspend( int hostID, unsigned long* retVal )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;
    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::suspend( instanceStore[0], retVal );

    return MNLBMachine_SUCCESS;
}


// drainstop
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::drainstop( int hostID, unsigned long* retVal )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;
    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::drainstop( instanceStore[0], retVal );

    return MNLBMachine_SUCCESS;
}


// disable
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::disable( int hostID, unsigned long* retVal, unsigned long portToAffect )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;

    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::disable( instanceStore[0], retVal, portToAffect );

    return MNLBMachine_SUCCESS;
}


// enable
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::enable( int hostID, unsigned long* retVal, unsigned long portToAffect )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;

    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::enable( instanceStore[0], retVal, portToAffect );

    return MNLBMachine_SUCCESS;
}


// drain
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::drain( int hostID, unsigned long* retVal, unsigned long portToAffect )
{
    // get the specific instance to run method on.
    vector< MWmiInstance >  instanceStore;

    getInstanceToRunMethodOn( hostID, &instanceStore );

    MNLBExe::drain( instanceStore[0], retVal, portToAffect );

    return MNLBMachine_SUCCESS;
}


// reload
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::reload( unsigned long* retVal )
{
    vector<MWmiInstance >           instanceStoreClusterSetting;
    _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
    p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting",
                                    relPath,
                                    &instanceStoreClusterSetting );

    // input parameters are none.
    //
    vector<MWmiParameter *> inputParameters;
            
    //  output parameters which are of interest.
    //
    vector<MWmiParameter *> outputParameters;
    MWmiParameter    returnValue(L"ReturnValue");
    outputParameters.push_back( &returnValue );
            
    instanceStoreClusterSetting[0].runMethod( L"LoadAllSettings",
                                              inputParameters,
                                              outputParameters );

    *retVal = ( long ) returnValue.getValue();

    return MNLBMachine_SUCCESS;
}    


// getInstanceToRunMethodOn
MNLBMachine::MNLBMachine_Error
MNLBMachine::getInstanceToRunMethodOn( int hID, vector <MWmiInstance>* instanceStore )
{
    vector<MWmiInstance> instanceStoreX;

    _bstr_t relPath;

    // see if we want to run clusterwide or host specific method.
    if( hID == Common::ALL_HOSTS )  
    {
        // cluster wide
        relPath = L"MicrosoftNLB_Cluster.Name=\"" + mClusterIP + L"\"";
        p_machine->getSpecificInstance( L"MicrosoftNLB_Cluster",
                                        relPath,
                                        &instanceStoreX );

        instanceStore->push_back( instanceStoreX[0] );
    }
    else if( hID == Common::THIS_HOST )
    {
        // this host specific
        relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + mHostID + L"\"";
        p_machine->getSpecificInstance( L"MicrosoftNLB_Node",
                                               relPath,
                                               &instanceStoreX );
        instanceStore->push_back( instanceStoreX[0] );

    }
    else
    { 
        // some other host

        // convert hID into string
        wchar_t hostIDBuf[1000];
        swprintf( hostIDBuf, L"%d", hID );

        relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + hostIDBuf + L"\"";
        p_machine->getSpecificInstance( L"MicrosoftNLB_Node",
                                               relPath,
                                               &instanceStoreX );

        instanceStore->push_back( instanceStoreX[0] );
    }
                
    return MNLBMachine_SUCCESS;
}
    
    
// refreshConnection
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::refreshConnection()
{
    return connectToMachine();
}


// connectToMachine
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::connectToMachine()
{
    MTrace* trace = MTrace::Instance();

    MTrace::TraceLevel prevLevel = trace->GetLevel();
    vector<HostProperties> hostPropertiesStore;

    // basically two operations need to succeed.
    // 1.  Is machine ip specified usable or not.
    // 2.  Is the nic specified bound to nlbs or not.
    //

    // connect to machine
    //
    if( mIP == _bstr_t( L"self")  )
    {
        // we want to connect to self machine.
        p_machine = auto_ptr< MWmiObject > ( new MWmiObject( L"root\\microsoftnlb") );
    }
    else if( mIP == mClusterIP )
    {
        // connecting to cluster remotely using cluster ip.  
        try
        {
            trace->SetLevel( MTrace::NO_TRACE );

            p_machine = auto_ptr<MWmiObject> ( new MWmiObject(  mIP,
                                                                L"root\\microsoftnlb",
                                                                L"Administrator",
                                                                L"" ) );
        }
        catch( _com_error e )
        {
            trace->SetLevel( prevLevel );
            TRACE(MTrace::INFO, L"connection using clusterip has failed\n" );
                    
            // Now we will be using api call wlbs query as situation may be that all hosts in cluster are stopped, and no connection
            // can be established to cluster ip, or there may be no such cluster and we will throw exception.
            //
            
            // get all hosts participating in cluster.
            DWORD ret = Common::getHostsInCluster( mClusterIP, &hostPropertiesStore );
            if( hostPropertiesStore.size() == 0 )
            {
                // no hosts are in this cluster.  Cannot proceed reliably.
                wstring errString;
                errString = L"cluster " +  wstring( mClusterIP ) + L" reported as having no hosts.  Maybe cluster ip is wrong, or remote control is turned off\n";
                TRACE( MTrace::SEVERE_ERROR, errString );

                throw _com_error( WBEM_E_NOT_FOUND );
            }

            // check if any host has dedicated ip not present
            // if this is so then object may not function reliably.
            bool allZero = true;
            int validHost;
            for( int i = 0; i < hostPropertiesStore.size(); ++i )
            {
                if( hostPropertiesStore[i].hIP == _bstr_t( L"0.0.0.0" ) )
                {
                    // host does not have valid dedicated ip.
                    TRACE( MTrace::SEVERE_ERROR, "a host has no dedicated ip.  Some object operations may not work as expected\n");
                }
                else
                {
                    // not all hosts have dedicated ip not filled in. 
                    // keep a track of this host.
                    allZero = false;
                    validHost = i;
                }
            }

            // check if all hosts had invalid dedicated ip.
            if( allZero == true )
            {
                // all hosts have dedicated ip invalid.
                TRACE( MTrace::SEVERE_ERROR, "all cluster hosts have dedicated ip 0.0.0.0\n");
                throw _com_error( WBEM_E_INVALID_PROPERTY );
            }
        
            p_machine = auto_ptr<MWmiObject>( new MWmiObject( hostPropertiesStore[validHost].hIP,
                                                              L"root\\microsoftnlb",
                                                              L"Administrator",
                                                              L"") );
        }
    }
    else
    {
        // we want to connect to remote machine.
        p_machine = auto_ptr<MWmiObject> ( new MWmiObject(  mIP,
                                                            L"root\\microsoftnlb",
                                                            L"Administrator",
                                                            L"" ) );
    }


    // check if specified cluster ip exists on this machine
    // and find the host id corresponding to this cluster on this machine.
    checkClusterIPAndSetHostID();

    return MNLBMachine_SUCCESS;
}

MNLBMachine::MNLBMachine_Error
MNLBMachine::checkClusterIPAndSetHostID()
{
    // set parameter to get.
    // we are interested in name.
    //
    vector<MWmiParameter* >   parameterStore;

    MWmiParameter Name(L"Name");
    parameterStore.push_back( &Name );

    // get instances of clustersetting class.    
    //
    vector< MWmiInstance >    instanceStore;
    bool found = false;
    int  i;

    p_machine->getInstances( L"Microsoftnlb_ClusterSetting",
                             &instanceStore );
    found = false;
    for( i = 0; i < instanceStore.size(); ++i )
    {
        instanceStore[i].getParameters( parameterStore );

        WTokens        tok;
        vector<wstring> tokens;
        tok.init( wstring( _bstr_t(Name.getValue()) ),
                  L":" );
        tokens = tok.tokenize();
            
        _bstr_t clusterIP = tokens[0].c_str();
        mHostID = tokens[1].c_str();

        if( mClusterIP == clusterIP )
        {
            // right object found
            found = true;
            break;
        }
    }
    
    if( found == false )
    {
        TRACE(
            MTrace::SEVERE_ERROR, 
            L"this machine does not have any cluster with specified cluster ip\n");
        throw _com_error( WBEM_E_NOT_FOUND );
    }

    return MNLBMachine_SUCCESS;
}


// getPresentHostsInfo
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::getPresentHostsInfo( 
    vector< MNLBMachine::HostInfo >* hostInfoStore)
{
    vector<MWmiParameter* >   parameterStore;
    
    MWmiParameter  Name(L"Name");
    parameterStore.push_back( &Name );

    MWmiParameter  DedicatedIPAddress(L"DedicatedIPAddress");
    parameterStore.push_back( &DedicatedIPAddress );

    vector< MWmiInstance >    instanceStore;

    p_machine->getInstances( L"MicrosoftNLB_Node",
                             &instanceStore );
    for( int i = 0; i < instanceStore.size(); ++i )
    {
        instanceStore[i].getParameters( parameterStore );

        // Name is in format of "clusterIP:hostID"
        //
        WTokens        tok;
        vector<wstring> tokens;
        tok.init( wstring( _bstr_t(Name.getValue()) ),
                  L":" );
        tokens = tok.tokenize();
        _bstr_t clusterIP = tokens[0].c_str();

        if( mClusterIP == clusterIP )
        {
            HostInfo hostInfo;
            hostInfo.hostID = _wtoi( tokens[1].c_str() );
            hostInfo.dedicatedIP = DedicatedIPAddress.getValue();
            
            hostInfoStore->push_back( hostInfo );
        }
    }

    return MNLBMachine_SUCCESS;
}


// setPassword
//
MNLBMachine::MNLBMachine_Error
MNLBMachine::setPassword( const _bstr_t& password,
                          unsigned long* retVal 
                          )
{
    // form path
    _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\"";

    vector<MWmiInstance >           instanceStoreClusterSetting;
    p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting",
                                    relPath,
                                    &instanceStoreClusterSetting );

    // input parameters is password
    //
    vector<MWmiParameter *> inputParameters;
    MWmiParameter    Password(L"Password");
    Password.setValue( password );
    inputParameters.push_back( &Password );
            
    // output parameters which are of interest.
    // none.
    //
    vector<MWmiParameter *> outputParameters;
            
    instanceStoreClusterSetting[0].runMethod( L"SetPassword",
                                              inputParameters,
                                              outputParameters );

    reload( retVal );

    return MNLBMachine_SUCCESS;
}