#include "CommonNLB.h"

#include "MNLBCluster.h"
#include "MNLBHost.h"
#include "MNLBMachine.h"
#include "MNLBNetCfg.h"
#include "MWmiError.h"
#include "MUsingCom.h"

#include "MIPAddressAdmin.h"

#include "ResourceString.h"
#include "resource.h"

#include <vector>
#include <memory>
#include <algorithm>
#include <algorithm>

using namespace std;

// global only temporarily.
//
LeftView* g_leftView;

CommonNLB::CommonNLB_Error
CommonNLB::connectToClusterDirect( const _bstr_t&          clusterIP,
                                   const _bstr_t&          hostMember,
                                   ClusterData*            p_clusterData,
                                   DataSinkI*              dataSinkObj )
{

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_CONNECTING) + hostMember );

    MNLBMachine nlbMachine( hostMember,
                            clusterIP );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE) );


    vector<MNLBMachine::HostInfo> hostInfo;

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_FINDING_H ) );

    nlbMachine.getPresentHostsInfo( &hostInfo );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE) );

    vector< _bstr_t> connectionIPS;

    for( int i = 0; i < hostInfo.size(); ++i )
    {
        connectionIPS.push_back( hostInfo[i].dedicatedIP );
    }


#if 1
    return connectToClusterIndirect( clusterIP,
                                     connectionIPS,
                                     p_clusterData,
                                     dataSinkObj );
#else
    vector<ClusterData> clusterDataStore;
    bool clusterPropertiesMatched;

    connectToClusterIndirectNew( clusterIP,
                                 connectionIPS,
                                 &clusterDataStore,
                                 clusterPropertiesMatched,
                                 dataSinkObj );
    (*p_clusterData) = clusterDataStore[0];

    return CommonNLB_SUCCESS;
#endif
}
    

CommonNLB::CommonNLB_Error
CommonNLB::connectToClusterIndirectNew( const _bstr_t&          clusterIP,
                                        const vector<_bstr_t>&  connectionIPS,
                                        vector< ClusterData>*   clusterDataStore,
                                        bool&                   clusterPropertiesMatched,
                                        DataSinkI*              dataSinkObj )

{
    // connect to each host.  
    // We are doing it here so that if there are any connectivity issues
    // we do not proceed with any further operation and ask user to
    // fix all issues before proceeding. 

    // connect to each host.
    map< bstr_t, auto_ptr<MNLBMachine> > nlbMachine;

    for( int i = 0; i < connectionIPS.size(); ++i )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_CONNECTING) + connectionIPS[i] );


        auto_ptr<MNLBMachine> p_nlbMachine = 
            auto_ptr<MNLBMachine> ( new MNLBMachine( connectionIPS[i],
                                                     clusterIP ) );
        nlbMachine[connectionIPS[i] ] = p_nlbMachine;

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );
    }

    // get information from each host.
    //
    for( int i = 0; i < connectionIPS.size(); ++i )
    {

        ClusterData clusterData;
        
        // get cluster properties.
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_FINDING_CL_P ) );

        ClusterProperties cp;

        nlbMachine[connectionIPS[i] ]->getClusterProperties( &cp );

        clusterData.cp = cp;

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );

        // get host properties.
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_FINDING_H_P ) );

        HostProperties hp;

        nlbMachine[connectionIPS[i] ]->getHostProperties( &hp );

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );

        // set the host properties
        HostData hostData;

        hostData.hp = hp;

        // set the connection ip.
        hostData.connectionIP = connectionIPS[i];

        clusterData.hosts[hp.machineName] = hostData;

        // get port rules
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_FINDING_P ) );

        vector<MNLBPortRuleLoadBalanced> portsLB;
        vector<MNLBPortRuleFailover> portsF;
        vector<MNLBPortRuleDisabled> portsD;

        PortDataULB ulbPortRule;

        PortDataF fPortRule;

        PortDataELB elbPortRule;

        PortDataD dPortRule;

        nlbMachine[connectionIPS[i] ]->getPortRulesLoadBalanced( &portsLB );
        for( int j = 0; j < portsLB.size(); ++j )
        {
            if( portsLB[j]._isEqualLoadBalanced == true )
            {
                // equal load balanced port rule.
                elbPortRule._startPort = portsLB[j]._startPort;
                elbPortRule._key = portsLB[j]._startPort;
                elbPortRule._endPort   = portsLB[j]._endPort;
                elbPortRule._trafficToHandle   = portsLB[j]._trafficToHandle;
                elbPortRule._affinity   = portsLB[j]._affinity;

                clusterData.portELB[portsLB[j]._startPort] = elbPortRule;
            }
            else
            {
                ulbPortRule._startPort = portsLB[j]._startPort;
                ulbPortRule._key = portsLB[j]._startPort;
                ulbPortRule._endPort   = portsLB[j]._endPort;
                ulbPortRule._trafficToHandle   = portsLB[j]._trafficToHandle;
                ulbPortRule._affinity   = portsLB[j]._affinity;

                ulbPortRule.machineMapToLoadWeight[hp.machineName]  = portsLB[j]._load;

                clusterData.portULB[portsLB[j]._startPort] = ulbPortRule;
            }
        }
        portsLB.erase( portsLB.begin(), portsLB.end() );

        nlbMachine[connectionIPS[i] ]->getPortRulesFailover( &portsF );
        for( int j = 0; j < portsF.size(); ++j )
        {
            fPortRule._startPort = portsF[j]._startPort;
            fPortRule._key = portsF[j]._startPort;
            fPortRule._endPort   = portsF[j]._endPort;
            fPortRule._trafficToHandle   = portsF[j]._trafficToHandle;

            fPortRule.machineMapToPriority[ hp.machineName] = portsF[j]._priority;
                
            clusterData.portF[portsF[j]._startPort] = fPortRule;
        }
        portsF.erase( portsF.begin(), portsF.end() );

        // disabled port rules
        nlbMachine[connectionIPS[i] ]->getPortRulesDisabled( &portsD );

        for( int j = 0; j < portsD.size(); ++j )
        {
            dPortRule._startPort = portsD[j]._startPort;
            dPortRule._key = portsD[j]._startPort;
            dPortRule._endPort   = portsD[j]._endPort;
            dPortRule._trafficToHandle   = portsD[j]._trafficToHandle;
            
            clusterData.portD[portsD[j]._startPort] = dPortRule;
        }
        portsD.erase( portsD.begin(), portsD.end() );

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );

        // get virtual ips.  These have already been got when we got the host properties
        // Thus here we are storing duplicate data, but this does ease
        // a lot of data structure manipulation.
        //
        
        clusterData.virtualIPs = clusterData.hosts[hp.machineName].hp.nicInfo.ipsOnNic;
        clusterData.virtualSubnets = clusterData.hosts[hp.machineName].hp.nicInfo.subnetMasks;

        clusterData.hosts[hp.machineName] = hostData;

        clusterDataStore->push_back( clusterData );

    }

    // now we will verify whether the cluster is 
    // converged or there are mismatches.

    // rules for a converged cluster.
    // 
    // cluster properties which need to 
    // be same:
    // cluster ip
    // cluster subnet 
    // full internet name
    // cluster mode
    // remote Control Enabled.
    // 
    // host properties
    // host id has to be unique across hosts any 
    // number from 1-32 inclusive.
    //
    // port rules
    // equal load balanced port rules have to be same
    // disabled port rules have to be same.
    // unequal load balanced port rules can differ only in load.
    // single host port rules can differ in priority, which has to be 
    // unique across hosts for a specific port rule any number between 1-32.
    //
    // Each machine must have the cluster ip.
    //
    // Each machine must have the exactly same ips on the nic.

    clusterPropertiesMatched = true;

    // check if cluster ip is added.
    //
    if( find( (*clusterDataStore)[0].virtualIPs.begin(),
              (*clusterDataStore)[0].virtualIPs.end(),
              (*clusterDataStore)[0].cp.cIP ) == (*clusterDataStore)[0].virtualIPs.end() )
    {
        clusterPropertiesMatched = false;
    }

    if( clusterDataStore->size() == 1 )
    {
        // only one host in cluster so only
        return CommonNLB_SUCCESS;
    }
    
    // sort the virtual ips of the first node.  Eases
    // comparision.
    sort( (*clusterDataStore)[0].virtualIPs.begin(),
          (*clusterDataStore)[0].virtualIPs.end() );

    for( int i = 1; i < clusterDataStore->size(); ++i )
    {
        // cluster properties must match.
        //

        if( (*clusterDataStore)[0].cp 
            != 
            (*clusterDataStore)[i].cp )
        {
            // mismatch in cluster properties.
            // MISMATCH
            clusterPropertiesMatched = false;
        }

        // the ELB, ULB, F, D port rules have to
        // match.
        if ( (*clusterDataStore)[0].portELB.size() 
             !=
             (*clusterDataStore)[i].portELB.size() )
        {
            // mismatch in port rules.
            // MISMATCH
            clusterPropertiesMatched = false;
        }
        else
        {
            // number of port rules are matching.
            map<long, PortDataELB>::iterator top;
            map<long, PortDataELB>::iterator location;            
            for( top = (*clusterDataStore)[i].portELB.begin();
                 top != (*clusterDataStore)[i].portELB.end();
                 ++top )
            {
                location = (*clusterDataStore)[0].portELB.find( (*top).first );
                if( location == (*clusterDataStore)[0].portELB.end() )
                {
                    // no such port exists.
                    // thus mismatch.
                    // MISMATCH
                    clusterPropertiesMatched = false;
                }
                else
                {
                    if( (*location).second._startPort != (*top).second._startPort 
                        ||
                        (*location).second._endPort != (*top).second._endPort 
                        ||
                        (*location).second._trafficToHandle != (*top).second._trafficToHandle
                        ||
                        (*location).second._affinity != (*top).second._affinity
                        )
                    {
                        // things other than key which is start port 
                        // has been modified.
                        // MISMATCH
                    }
                }
            }
        }

        if ( (*clusterDataStore)[0].portULB.size() 
             !=
             (*clusterDataStore)[i].portULB.size() )
        {
            // mismatch in port rules.
            // MISMATCH
            clusterPropertiesMatched = false;
        }
        else
        {
            // number of port rules are matching.
            map<long, PortDataULB>::iterator top;
            map<long, PortDataULB>::iterator location;            
            for( top = (*clusterDataStore)[i].portULB.begin();
                 top != (*clusterDataStore)[i].portULB.end();
                 ++top )
            {
                location = (*clusterDataStore)[0].portULB.find( (*top).first );
                if( location == (*clusterDataStore)[0].portULB.end() )
                {
                    // no such port exists.
                    // thus mismatch.
                    // MISMATCH
                    clusterPropertiesMatched = false;
                }
                else
                {
                    if( (*location).second._startPort != (*top).second._startPort 
                        ||
                        (*location).second._endPort != (*top).second._endPort 
                        ||
                        (*location).second._trafficToHandle != (*top).second._trafficToHandle
                        ||
                        (*location).second._affinity != (*top).second._affinity
                        )
                    {
                        // things other than key which is start port 
                        // has been modified.
                        // MISMATCH
                        clusterPropertiesMatched = false;
                    }
                }
            }

        }

        if ( (*clusterDataStore)[0].portF.size() 
             !=
             (*clusterDataStore)[i].portF.size() )
        {
            // mismatch in port rules.
            // MISMATCH
            clusterPropertiesMatched = false;
        }
        else
        {
            // number of port rules are matching.
            map<long, PortDataF>::iterator top;
            map<long, PortDataF>::iterator location;            
            for( top = (*clusterDataStore)[i].portF.begin();
                 top != (*clusterDataStore)[i].portF.end();
                 ++top )
            {
                location = (*clusterDataStore)[0].portF.find( (*top).first );
                if( location == (*clusterDataStore)[0].portF.end() )
                {
                    // no such port exists.
                    // thus mismatch.
                    // MISMATCH
                    clusterPropertiesMatched = false;
                }
                else
                {
                    if( (*location).second._startPort != (*top).second._startPort 
                        ||
                        (*location).second._endPort != (*top).second._endPort 
                        ||
                        (*location).second._trafficToHandle != (*top).second._trafficToHandle
                        )
                    {
                        // things other than key which is start port 
                        // has been modified.
                        // MISMATCH
                        clusterPropertiesMatched = false;
                    }
                }
            }
        }

        if ( (*clusterDataStore)[0].portD.size() 
             !=
             (*clusterDataStore)[i].portD.size() )
        {
            // mismatch in port rules.
            // MISMATCH
            clusterPropertiesMatched = false;
        }
        else
        {
            // number of port rules are matching.
            map<long, PortDataD>::iterator top;
            map<long, PortDataD>::iterator location;            
            for( top = (*clusterDataStore)[i].portD.begin();
                 top != (*clusterDataStore)[i].portD.end();
                 ++top )
            {
                location = (*clusterDataStore)[0].portD.find( (*top).first );
                if( location == (*clusterDataStore)[0].portD.end() )
                {
                    // no such port exists.
                    // thus mismatch.
                    // MISMATCH
                    clusterPropertiesMatched = false;
                }
                else
                {
                    if( (*location).second._startPort != (*top).second._startPort 
                        ||
                        (*location).second._endPort != (*top).second._endPort 
                        ||
                        (*location).second._trafficToHandle != (*top).second._trafficToHandle
                        )
                    {
                        // things other than key which is start port 
                        // has been modified.
                        // MISMATCH
                        clusterPropertiesMatched = false;
                    }
                }
            }
        }


        // check if each machine has the same virtual ips.
        //
        sort( (*clusterDataStore)[i].virtualIPs.begin(),
              (*clusterDataStore)[i].virtualIPs.end() );

        if( (*clusterDataStore)[0].virtualIPs
            != 
            (*clusterDataStore)[i].virtualIPs )
        {
            // MISMATCH
            clusterPropertiesMatched = false;
        }
    }

    // check if host ids are duplicate.
    map< _bstr_t, HostData>::iterator  onlyHost;    
    set<int> hostIDS;

    for( int i = 0; i < clusterDataStore->size(); ++i )    
    {
        onlyHost = (*clusterDataStore)[i].hosts.begin();

        // check if this host id has been used previously.
        if( hostIDS.find( (*onlyHost).second.hp.hID ) == hostIDS.end() )
        {
            // host id is unused.
            hostIDS.insert( (*onlyHost).second.hp.hID );
        }
        else
        {
            // host id has been used previously. 
            // Thus this is duplicate.
            // MISMATCH
            clusterPropertiesMatched = false;
        }
    }

    if( clusterPropertiesMatched == true )
    {
        // combine all the host information.
        //
        map<_bstr_t, HostData >::iterator top;
        for( int i = 1; i < clusterDataStore->size(); ++i )
        {
            top = (*clusterDataStore)[i].hosts.begin();

            (*clusterDataStore)[0].hosts[ (*top).first ] = (*top).second;
        }

#if 1
        // combine all the port information for ULB and disabled port rules.
        // this may be a little difficult, but it works.  Don't fiddle around
        // with this part.
        map<long, PortDataULB>::iterator topULB;        
        for( topULB = (*clusterDataStore)[0].portULB.begin();
             topULB != (*clusterDataStore)[0].portULB.end();
             ++topULB )
        {
            map<_bstr_t, long>& ref = (*topULB).second.machineMapToLoadWeight;
            
            for( int i = 1; i < clusterDataStore->size(); ++i )
            {
                // find the machine name for this clusterdata.
                map<_bstr_t, HostData>::iterator top;

                top = (*clusterDataStore)[i].hosts.begin();

                _bstr_t machineName = (*top).first;

                ref[machineName] = 
                    (*clusterDataStore)[i].portULB[ (*topULB).first ].machineMapToLoadWeight[ machineName];
            }
        }

        map<long, PortDataF>::iterator topF;        
        for( topF = (*clusterDataStore)[0].portF.begin();
             topF != (*clusterDataStore)[0].portF.end();
             ++topF )
        {
            map<_bstr_t, long>& ref = (*topF).second.machineMapToPriority;
            
            for( int i = 1; i < clusterDataStore->size(); ++i )
            {
                // find the machine name for this clusterdata.
                map<_bstr_t, HostData>::iterator top;

                top = (*clusterDataStore)[i].hosts.begin();

                _bstr_t machineName = (*top).first;

                ref[machineName] = 
                    (*clusterDataStore)[i].portF[ (*topF).first ].machineMapToPriority[ machineName];
            }
        }

#endif

    }

    return CommonNLB_SUCCESS;
}
    

CommonNLB::CommonNLB_Error
CommonNLB::connectToClusterIndirect( const _bstr_t&          clusterIP,
                                     const vector<_bstr_t>&  connectionIPS,
                                     ClusterData*            p_clusterData,
                                     DataSinkI*              dataSinkObj )
{
    // connect to each host.  
    // We are doing it here so that if there are any connectivity issues
    // we do not proceed with any further operation and ask user to
    // fix all issues before proceeding. 

    // connect to each host.
    map< bstr_t, auto_ptr<MNLBMachine> > nlbMachine;

    for( int i = 0; i < connectionIPS.size(); ++i )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_CONNECTING) + connectionIPS[i] );


        auto_ptr<MNLBMachine> p_nlbMachine = 
            auto_ptr<MNLBMachine> ( new MNLBMachine( connectionIPS[i],
                                                     clusterIP ) );
        nlbMachine[connectionIPS[i] ] = p_nlbMachine;

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );
    }

    // rules for a converged cluster.
    // 
    // cluster properties which need to 
    // be same:
    // cluster ip
    // cluster subnet 
    // full internet name
    // cluster mode
    // 
    // host properties
    // host id has to be unique across hosts any 
    // number from 1-32 inclusive.
    //
    // port rules
    // equal load balanced port rules have to be same
    // disabled port rules have to be same.
    // unequal load balanced port rules can differ only in load.
    // single host port rules can differ in priority, which has to be 
    // unique across hosts for a specific port rule any number between 1-32.
    //

    
    for( int i = 0; i < connectionIPS.size(); ++i )
    {
        
        // get cluster properties.
        // cluster properties need to be got only for one host.
        if( i == 0 )
        {
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_FINDING_CL_P ) );

            ClusterProperties cp;

            nlbMachine[connectionIPS[i] ]->getClusterProperties( &cp );

            p_clusterData->cp = cp;

            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE) );

        }

        // get host properties.
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_FINDING_H_P ) );

        HostProperties hp;

        nlbMachine[connectionIPS[i] ]->getHostProperties( &hp );

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );

        // set the host properties
        HostData hostData;

        hostData.hp = hp;

        // set the connection ip.
        hostData.connectionIP = connectionIPS[i];

        p_clusterData->hosts[hp.machineName] = hostData;

        // get port rules
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_FINDING_P ) );


        vector<MNLBPortRuleLoadBalanced> portsLB;
        vector<MNLBPortRuleFailover> portsF;
        vector<MNLBPortRuleDisabled> portsD;

        PortDataULB ulbPortRule;

        PortDataF fPortRule;

        PortDataELB elbPortRule;

        PortDataD dPortRule;

        nlbMachine[connectionIPS[i] ]->getPortRulesLoadBalanced( &portsLB );
        for( int j = 0; j < portsLB.size(); ++j )
        {
            if( portsLB[j]._isEqualLoadBalanced == true )
            {
                // equal load balanced port rule.
                elbPortRule._startPort = portsLB[j]._startPort;
                elbPortRule._key = portsLB[j]._startPort;
                elbPortRule._endPort   = portsLB[j]._endPort;
                elbPortRule._trafficToHandle   = portsLB[j]._trafficToHandle;
                elbPortRule._affinity   = portsLB[j]._affinity;

                p_clusterData->portELB[portsLB[j]._startPort] = elbPortRule;
            }
            else
            {
                // unequal load balanced.
                if( i == 0 )
                {
                    ulbPortRule._startPort = portsLB[j]._startPort;
                    ulbPortRule._key = portsLB[j]._startPort;
                    ulbPortRule._endPort   = portsLB[j]._endPort;
                    ulbPortRule._trafficToHandle   = portsLB[j]._trafficToHandle;
                    ulbPortRule._affinity   = portsLB[j]._affinity;

                    ulbPortRule.machineMapToLoadWeight[hp.machineName]  = portsLB[j]._load;

                    p_clusterData->portULB[portsLB[j]._startPort] = ulbPortRule;
                }
                else
                {
                    p_clusterData->portULB[portsLB[j]._startPort].machineMapToLoadWeight[ hp.machineName]  = portsLB[j]._load;
                }
            }
        }
        portsLB.erase( portsLB.begin(), portsLB.end() );

        nlbMachine[connectionIPS[i] ]->getPortRulesFailover( &portsF );
        for( int j = 0; j < portsF.size(); ++j )
        {
            if( i == 0 )
            {
                fPortRule._startPort = portsF[j]._startPort;
                fPortRule._key = portsF[j]._startPort;
                fPortRule._endPort   = portsF[j]._endPort;
                fPortRule._trafficToHandle   = portsF[j]._trafficToHandle;

                fPortRule.machineMapToPriority[ hp.machineName] = portsF[j]._priority;
                
                p_clusterData->portF[portsF[j]._startPort] = fPortRule;
            }
            else
            {
                p_clusterData->portF[portsF[j]._startPort].machineMapToPriority[ hp.machineName]  = portsF[j]._priority;
            }
        }
        portsF.erase( portsF.begin(), portsF.end() );

        // disabled need to be got only once.
        if( i == 0 )
        {
            nlbMachine[connectionIPS[i] ]->getPortRulesDisabled( &portsD );

            for( int j = 0; j < portsD.size(); ++j )
            {
                dPortRule._startPort = portsD[j]._startPort;
                dPortRule._key = portsD[j]._startPort;
                dPortRule._endPort   = portsD[j]._endPort;
                dPortRule._trafficToHandle   = portsD[j]._trafficToHandle;

                p_clusterData->portD[portsD[j]._startPort] = dPortRule;
            }
            portsD.erase( portsD.begin(), portsD.end() );
        }

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );
    }

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_SUCCESS ) );

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::connectToMachine( 
    const _bstr_t&                             machineToConnect,
    _bstr_t&                                   machineServerName,
    vector< CommonNLB::NicNLBBound >&          nicList,
    DataSinkI*                                 dataSinkObj )
{
    // connect to machine.
    //
    MWmiObject machine( machineToConnect,
                        L"root\\microsoftnlb",
                        L"administrator",
                        L"" );

    // find all nics on machine.
    //
    vector<MWmiInstance> instanceStore;
    machine.getInstances( L"NlbsNic",
                          &instanceStore );

    // check if nic has nlb bound.
    //
    // input parameters are none.
    //
    vector<MWmiParameter *> inputParameters;

    //  output parameters which are of interest.
    //
    vector<MWmiParameter *> outputParameters;
    MWmiParameter    ReturnValue(L"ReturnValue");
    outputParameters.push_back( &ReturnValue );

    vector<MWmiParameter *> parameterStore;

    MWmiParameter Server(L"__Server");
    parameterStore.push_back( &Server );

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

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

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

    for( int i = 0; i < instanceStore.size(); ++i )
    {
        // get full name, guid and friendly name.
        //
        NicNLBBound temp;

        instanceStore[i].getParameters( parameterStore );
        temp.fullNicName = FullName.getValue();
        temp.adapterGuid = AdapterGuid.getValue();
        temp.friendlyName = FriendlyName.getValue();

        // get machine name.
        machineServerName = Server.getValue();

        // check if nic is bound to nlb or not.
        instanceStore[i].runMethod( L"isBound",
                                    inputParameters, 
                                    outputParameters );
        if( long( ReturnValue.getValue() ) == 1 )
        {
            // this nic is bound.
            temp.isBoundToNLB = true;
        }
        else
        {
            temp.isBoundToNLB = false;
        }

        // get all the ip's on this nic.
        MIPAddressAdmin ipAdmin( machineToConnect,
                                 temp.fullNicName );

        ipAdmin.getIPAddresses( &temp.ipsOnNic,
                                &temp.subnetMasks );

        // check if the nic is dhcp.
        ipAdmin.isDHCPEnabled( temp.dhcpEnabled );
                                 
        nicList.push_back( temp );
    }

    return CommonNLB_SUCCESS;
}
    

CommonNLB::CommonNLB_Error
CommonNLB::changeNLBClusterSettings( const ClusterData*        oldSettings,
                                     const ClusterData*        newSettings,
                                     DataSinkI*                dataSinkObj )
{
    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::changeNLBHostSettings( const ClusterData*        oldSettings,
                                  const ClusterData*        newSettings,
                                  const _bstr_t&            machineName,
                                  DataSinkI*                dataSinkObj )
{
    ClusterData* oldSettingsCopy = const_cast <ClusterData *>( oldSettings );
    ClusterData* newSettingsCopy = const_cast <ClusterData *>( newSettings );

    map<_bstr_t, HostData>::iterator topOld;
    map<_bstr_t, HostData>::iterator topNew;

    // change host properties for  host if that have changed.
    //
    if( oldSettingsCopy->hosts[machineName].hp
        != 
        newSettingsCopy->hosts[machineName].hp )
    {
        // connect to machine.
        //
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_CONNECTING ) + 
            oldSettingsCopy->hosts[machineName].connectionIP );

        MNLBMachine nlbMachine( 
            oldSettingsCopy->hosts[machineName].connectionIP,
            oldSettingsCopy->cp.cIP );
        
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );
        
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_H_P ) );

        // host properties have changed.
        unsigned long returnValue;
        nlbMachine.setHostProperties( newSettingsCopy->hosts[machineName].hp,
                                      &returnValue );

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE) );
    }

    return CommonNLB_SUCCESS;
}


CommonNLB::CommonNLB_Error
CommonNLB::changeNLBHostPortSettings( const ClusterData*        oldSettings,
                                      const ClusterData*        newSettings,
                                      const _bstr_t&            machineName,
                                      DataSinkI*                dataSinkObj )
{
    ClusterData* oldSettingsCopy = const_cast <ClusterData *>( oldSettings );
    ClusterData* newSettingsCopy = const_cast <ClusterData *>( newSettings );

    map<_bstr_t, HostData>::iterator topOld;
    map<_bstr_t, HostData>::iterator topNew;

    // connect to machine.
    //
    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_CONNECTING ) + 
        oldSettingsCopy->hosts[machineName].connectionIP );

    MNLBMachine nlbMachine( 
        oldSettingsCopy->hosts[machineName].connectionIP,
        oldSettingsCopy->cp.cIP );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE ) );


    // check if any load weights have changed.
    // for any unequal load balanced port rule.
    //
    map<long, PortDataULB>::iterator topOldULB;    
    map<long, PortDataULB>::iterator topNewULB;    

    for( topOldULB = oldSettingsCopy->portULB.begin(), 
             topNewULB = newSettingsCopy->portULB.begin();
         topOldULB != oldSettingsCopy->portULB.end();
         ++topOldULB, ++topNewULB )
    {
        if( (*topOldULB).second.machineMapToLoadWeight[machineName]
            !=
            (*topNewULB).second.machineMapToLoadWeight[machineName] 
            )
        {
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_P_ULB ) );

            // load weight has changed.

            // remove old port rule
            MNLBPortRuleLoadBalanced portULB = (*topNewULB).second;
            portULB._load = 
                (*topOldULB).second.machineMapToLoadWeight[machineName];

            nlbMachine.removePortRuleLoadBalanced( portULB );

            // add this port rule.

            // only load weight can change.
            portULB._load = 
                (*topNewULB).second.machineMapToLoadWeight[machineName];

            nlbMachine.addPortRuleLoadBalanced( portULB );

            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
        }
    }

    // check if any priorities have changed.
    // for any failover port rules
    //
    map<long, PortDataF>::iterator topOldF;    
    map<long, PortDataF>::iterator topNewF;    

    for( topOldF = oldSettingsCopy->portF.begin(), 
             topNewF = newSettingsCopy->portF.begin();
         topOldF != oldSettingsCopy->portF.end();
         ++topOldF, ++topNewF )
    {
        if( (*topOldF).second.machineMapToPriority[machineName]
            !=
            (*topNewF).second.machineMapToPriority[machineName] 
            )
        {
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_P_F ) );

            // priority has changed.

            MNLBMachine nlbMachine( 
                newSettingsCopy->hosts[machineName].connectionIP,
                newSettingsCopy->cp.cIP );

            // remove old port rule
            MNLBPortRuleFailover portF = (*topNewF).second;
            portF._priority = 
                (*topOldF).second.machineMapToPriority[machineName];

            nlbMachine.removePortRuleFailover( portF );

            // add new port rule.

            // only priority has changed.
            portF._priority = 
                (*topNewF).second.machineMapToPriority[machineName];

            nlbMachine.addPortRuleFailover( portF );

            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
        }
    }

    return CommonNLB_SUCCESS;
}


CommonNLB::CommonNLB_Error
CommonNLB::changeNLBClusterAndPortSettings( const ClusterData*        oldSettings,
                                            const ClusterData*        newSettings,
                                            DataSinkI*                dataSinkObj,
                                            bool*                     pbClusterIpChanged)
{
    ClusterData* oldSettingsCopy = const_cast <ClusterData *>( oldSettings );
    ClusterData* newSettingsCopy = const_cast <ClusterData *>( newSettings );
    bool         bClusterParametersChanged, bPortRulesChanged, bOnlyClusterNameChanged;

    // Find out if the cluster parameters have changed. Also, find if the cluster name
    // is the only parameter that has changed
    bClusterParametersChanged = newSettingsCopy->cp.HaveClusterPropertiesChanged(oldSettingsCopy->cp, 
                                                                                 &bOnlyClusterNameChanged,
                                                                                 pbClusterIpChanged);
    vector<long> rulesAddedELB;
    vector<long> rulesUnchangedELB;
    vector<long> rulesRemovedELB;

    findPortRulesAddedUnchangedRemovedELB( oldSettingsCopy,
                                           newSettingsCopy,
                                           dataSinkObj,
                                           rulesAddedELB,
                                           rulesUnchangedELB,
                                           rulesRemovedELB );


    vector<long> rulesAddedULB;
    vector<long> rulesUnchangedULB;
    vector<long> rulesRemovedULB;

    findPortRulesAddedUnchangedRemovedULB( oldSettingsCopy,
                                           newSettingsCopy,
                                           dataSinkObj,
                                           rulesAddedULB,
                                           rulesUnchangedULB,
                                           rulesRemovedULB );


    vector<long> rulesAddedD;
    vector<long> rulesUnchangedD;
    vector<long> rulesRemovedD;

    findPortRulesAddedUnchangedRemovedD( oldSettingsCopy,
                                         newSettingsCopy,
                                         dataSinkObj,
                                         rulesAddedD,
                                         rulesUnchangedD,
                                         rulesRemovedD );


    vector<long> rulesAddedF;
    vector<long> rulesUnchangedF;
    vector<long> rulesRemovedF;

    findPortRulesAddedUnchangedRemovedF( oldSettingsCopy,
                                         newSettingsCopy,
                                         dataSinkObj,
                                         rulesAddedF,
                                         rulesUnchangedF,
                                         rulesRemovedF );

    // check if any port rules have been added or removed 
    // if not we don't want to do anything.
    if(
        ( rulesAddedULB.size() == 0 )
        &&
        ( rulesRemovedULB.size() == 0 )
        &&
        ( rulesAddedELB.size() == 0 )
        &&
        ( rulesRemovedELB.size() == 0 )
        &&
        ( rulesAddedD.size() == 0 )
        &&
        ( rulesRemovedD.size() == 0 )
        &&
        ( rulesAddedF.size() == 0 )
        &&
        ( rulesRemovedF.size() == 0 )
        )
    {
        //return CommonNLB_SUCCESS;
        //OutputDebugString(_T("No Change to Port Rules\n"));
        bPortRulesChanged = false;
    }
    else
    {
        bPortRulesChanged = true;
    }

    // Neither the cluster parameters nor the port rules have changed, so return
    if (!bClusterParametersChanged && !bPortRulesChanged)
    {
        //OutputDebugString(_T("No Change to Cluster Parameters or Port Rules\n"));
        return CommonNLB_SUCCESS;
    }

    // connect to each host.  
    // We are doing it here so that if there are any connectivity issues
    // we do not proceed with any changes and just inform the user.
    // This is to ensure that we do not cause any convergence.  

    // connect to each host.
    map<_bstr_t, HostData >::iterator top;
    map< bstr_t, auto_ptr<MNLBMachine> > nlbMachine;

    for( top = oldSettingsCopy->hosts.begin();
         top != oldSettingsCopy->hosts.end();
         ++top )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_CONNECTING ) 
            + (*top).second.connectionIP );

        auto_ptr<MNLBMachine> p_nlbMachine = 
            auto_ptr<MNLBMachine> ( new MNLBMachine( (*top).second.connectionIP,
                                                     oldSettingsCopy->cp.cIP ) );
        nlbMachine[(*top).first] = p_nlbMachine;

        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_INFO_DONE ) );

    }

    // for each host in cluster apply the changed port & cluster rules.
    for( top = oldSettingsCopy->hosts.begin();
         top != oldSettingsCopy->hosts.end();
         ++top )
    {
        if (bPortRulesChanged)
        {
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_P ) );

            // remove all port rules which need to be erased.. 
            //
            for( int i = 0; i < rulesRemovedELB.size(); ++i )
            {
                nlbMachine[ (*top).first ]->removePortRuleLoadBalanced( oldSettingsCopy->portELB[ rulesRemovedELB[i] ] );
            }

            for( int i = 0; i < rulesRemovedULB.size(); ++i )
            {
                nlbMachine[ (*top).first ]->removePortRuleLoadBalanced( oldSettingsCopy->portULB[ rulesRemovedULB[i] ] );
            }

            for( int i = 0; i < rulesRemovedD.size(); ++i )
            {
                nlbMachine[ (*top).first ]->removePortRuleDisabled( oldSettingsCopy->portD[ rulesRemovedD[i] ] );
            }

            for( int i = 0; i < rulesRemovedF.size(); ++i )
            {
                nlbMachine[ (*top).first ]->removePortRuleFailover( oldSettingsCopy->portF[rulesRemovedF[i] ] );
            }

            // add all new port rules
            //
            for( int i = 0; i < rulesAddedELB.size(); ++i )
            {
                nlbMachine[ (*top).first ]->addPortRuleLoadBalanced( newSettingsCopy->portELB[ rulesAddedELB[i] ] );
            }
            
            for( int i = 0; i < rulesAddedULB.size(); ++i )
            {
                MNLBPortRuleLoadBalanced portULB =  newSettingsCopy->portULB[ rulesAddedULB[i] ];

                _bstr_t machineName = (*top).first;

                portULB._load = 
                    newSettingsCopy->portULB[rulesAddedULB[i]].machineMapToLoadWeight[ (*top).first ]; 
                nlbMachine[ (*top).first ]->addPortRuleLoadBalanced( portULB );
            }

            for( int i = 0; i < rulesAddedD.size(); ++i )
            {
                nlbMachine[ (*top).first ]->addPortRuleDisabled( newSettingsCopy->portD[rulesAddedD[i] ] );
            }

            for( int i = 0; i < rulesAddedF.size(); ++i )
            {
                MNLBPortRuleFailover portF =  newSettingsCopy->portF[rulesAddedF[i] ];
                
                portF._priority = 
                newSettingsCopy->portF[rulesAddedF[i]].machineMapToPriority[ (*top).first ];
            
                nlbMachine[ (*top).first ]->addPortRuleFailover( portF );
            }
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
        }
        if (bClusterParametersChanged)
        {
            if (bOnlyClusterNameChanged)
            {
                unsigned long retVal;
                dataSinkObj->dataSink( 
                    GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_CN ) );
                nlbMachine[ (*top).first ]->setClusterProperties(newSettingsCopy->cp, &retVal);

                // if remote control is enabled set the password.
                // even if password has not changed just making extra call.
                if( newSettingsCopy->cp.remoteControlEnabled == true )
                {
                    nlbMachine[ (*top).first ]->setPassword(newSettingsCopy->cp.password, &retVal);                
                }

            }
            else // Cluster Parameters other than Cluster name have changed too
            {
                dataSinkObj->dataSink( 
                    GETRESOURCEIDSTRING( IDS_INFO_REMOVING_CL_IP ) );
                MNLBNetCfg nlbNetCfg((*top).second.connectionIP, (*top).second.hp.nicInfo.fullNicName);
                nlbNetCfg.removeClusterIP(oldSettingsCopy->cp.cIP);
            }
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
        }
    }

    // If Cluster Paraters other than the Cluster Name has changed, call the NLB Manager 
    // provider's "ModifyClusterProperties" (eventually) to modify cluster properties
    // and add the cluster ip to tcp/ip. Modification of the cluster properties will 
    // result in the disable/re-enable of the nic & hence the WMI DCOM connection might 
    // be lost. So, we are doing this two-step operation locally 
    
    if (bClusterParametersChanged && !bOnlyClusterNameChanged)
    {
        for( top = oldSettingsCopy->hosts.begin();
             top != oldSettingsCopy->hosts.end();
             ++top )
        {
            //OutputDebugString(_T("Modifying Cluster Parameters and adding cluster ip to tcp-ip !!!\n"));
            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_MODIFYING_CP_AND_ADD_IP ) );

            MNLBNetCfg* p_nlbNetCfg = NULL;
            ModifyClusterPropertiesParameters* par = NULL;
            try {
                p_nlbNetCfg = new MNLBNetCfg((*top).second.connectionIP, (*top).second.hp.nicInfo.fullNicName);

                par = new ModifyClusterPropertiesParameters;

                par->nlbNetCfg = p_nlbNetCfg;

                par->clusterData = NULL;
                par->clusterData = new ClusterData( *newSettingsCopy );
                
                par->machineName = new _bstr_t( (*top).second.hp.machineName );
                g_leftView = (LeftView *) dataSinkObj;

            }
            catch(...)
            {
                delete  par->clusterData;
                delete  par;
                delete  p_nlbNetCfg;

                dataSinkObj->dataSink(GETRESOURCEIDSTRING(IDS_INFO_NEW_EXCEPTION));
                throw;
            }

            AfxBeginThread( (AFX_THREADPROC) ModifyClusterPropertiesThread, par );

            dataSinkObj->dataSink( 
                GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
        }
    }
        
    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::findPortRulesAddedUnchangedRemovedELB( 
    const ClusterData*        oldSettings,
    const ClusterData*        newSettings,
    DataSinkI*                dataSinkObj,
    vector<long>&             rulesAdded,
    vector<long>&             rulesUnchanged,
    vector<long>&             rulesRemoved )
{
    map<long, PortDataELB>::iterator top;
    map<long, PortDataELB>::iterator location;

    // find ports which have been newly added or modified.
    //
    for( top = newSettings->portELB.begin();
         top != newSettings->portELB.end();
         ++top )
    {
        rulesAdded.push_back( (*top).first );
    }
    
    // find ports which have remain unchanged and ports which have 
    // been removed or modified.
    for( top = oldSettings->portELB.begin();
         top != oldSettings->portELB.end();
         ++top )
    {
        // check if this port rule has been removed or modified.
        location = newSettings->portELB.find( (*top).first ); 
        if( location == newSettings->portELB.end() )
        {
            // key has been removed
            rulesRemoved.push_back( (*top).first );
        }
        else
        {
            // may be things other than key are modified or totally
            // unchanged.
            if( (*location).second == (*top).second )
            {
                // totally unchanged
                rulesUnchanged.push_back( (*top).first );
                rulesAdded.erase (find( rulesAdded.begin(), 
                                        rulesAdded.end(), 
                                        (*top).first ) );
                
            }
            else
            {
                // key is same but the other parts are modified.
                rulesRemoved.push_back( (*top).first );
            }
        }
    }

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::findPortRulesAddedUnchangedRemovedULB( 
    const ClusterData*        oldSettings,
    const ClusterData*        newSettings,
    DataSinkI*                dataSinkObj,
    vector<long>&             rulesAdded,
    vector<long>&             rulesUnchanged,
    vector<long>&             rulesRemoved )
{
    map<long, PortDataULB>::iterator top;
    map<long, PortDataULB>::iterator location;

    // find ports which have been newly added or modified.
    //
    for( top = newSettings->portULB.begin();
         top != newSettings->portULB.end();
         ++top )
    {
        rulesAdded.push_back( (*top).first );
    }
    
    // find ports which have remain unchanged and ports which have 
    // been removed or modified.
    for( top = oldSettings->portULB.begin();
         top != oldSettings->portULB.end();
         ++top )
    {
        // check if this port rule has been removed or modified.
        location = newSettings->portULB.find( (*top).first ); 
        if( location == newSettings->portULB.end() )
        {
            // key has been removed
            rulesRemoved.push_back( (*top).first );
        }
        else
        {
            // may be things other than key are modified or totally
            // unchanged.
            if( (*location).second == (*top).second )
            {
                // totally unchanged
                rulesUnchanged.push_back( (*top).first );
                rulesAdded.erase (find( rulesAdded.begin(), 
                                        rulesAdded.end(), 
                                        (*top).first ) );
                
            }
            else
            {
                // key is same but the other parts are modified.
                rulesRemoved.push_back( (*top).first );
            }
        }
    }

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::findPortRulesAddedUnchangedRemovedD( 
    const ClusterData*        oldSettings,
    const ClusterData*        newSettings,
    DataSinkI*                dataSinkObj,
    vector<long>&             rulesAdded,
    vector<long>&             rulesUnchanged,
    vector<long>&             rulesRemoved )
{
    map<long, PortDataD>::iterator top;
    map<long, PortDataD>::iterator location;

    // find ports which have been newly added or modified.
    //
    for( top = newSettings->portD.begin();
         top != newSettings->portD.end();
         ++top )
    {
        rulesAdded.push_back( (*top).first );
    }
    
    // find ports which have remain unchanged and ports which have 
    // been removed or modified.
    for( top = oldSettings->portD.begin();
         top != oldSettings->portD.end();
         ++top )
    {
        // check if this port rule has been removed or modified.
        location = newSettings->portD.find( (*top).first ); 
        if( location == newSettings->portD.end() )
        {
            // key has been removed
            rulesRemoved.push_back( (*top).first );
        }
        else
        {
            // may be things other than key are modified or totally
            // unchanged.
            if( (*location).second == (*top).second )
            {
                // totally unchanged
                rulesUnchanged.push_back( (*top).first );
                rulesAdded.erase (find( rulesAdded.begin(), 
                                        rulesAdded.end(), 
                                        (*top).first ) );
                
            }
            else
            {
                // key is same but the other parts are modified.
                rulesRemoved.push_back( (*top).first );
            }
        }
    }

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::findPortRulesAddedUnchangedRemovedF( 
    const ClusterData*        oldSettings,
    const ClusterData*        newSettings,
    DataSinkI*                dataSinkObj,
    vector<long>&             rulesAdded,
    vector<long>&             rulesUnchanged,
    vector<long>&             rulesRemoved )
{
    map<long, PortDataF>::iterator top;
    map<long, PortDataF>::iterator location;

    // find ports which have been newly added or modified.
    //
    for( top = newSettings->portF.begin();
         top != newSettings->portF.end();
         ++top )
    {
        rulesAdded.push_back( (*top).first );
    }
    
    // find ports which have remain unchanged and ports which have 
    // been removed or modified.
    for( top = oldSettings->portF.begin();
         top != oldSettings->portF.end();
         ++top )
    {
        // check if this port rule has been removed or modified.
        location = newSettings->portF.find( (*top).first ); 
        if( location == newSettings->portF.end() )
        {
            // key has been removed
            rulesRemoved.push_back( (*top).first );
        }
        else
        {
            // may be things other than key are modified or totally
            // unchanged.
            if( (*location).second == (*top).second )
            {
                // totally unchanged
                rulesUnchanged.push_back( (*top).first );
                rulesAdded.erase (find( rulesAdded.begin(), 
                                        rulesAdded.end(), 
                                        (*top).first ) );
                
            }
            else
            {
                // key is same but the other parts are modified.
                rulesRemoved.push_back( (*top).first );
            }
        }
    }

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::removeCluster( const ClusterData* clusterSettings,
                          DataSinkI*         dataSinkObj )
{
    map<_bstr_t, HostData>::iterator top;

    for( top = clusterSettings->hosts.begin();
         top != clusterSettings->hosts.end();
         ++top )
    {
        removeHost( clusterSettings,
                    (*top).first,
                    dataSinkObj );
    }

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::removeHost( const ClusterData* clusterSettings,
                       const _bstr_t&     machineName,
                       DataSinkI*         dataSinkObj )
{
    ClusterData* clusterSettingsCopy = 
        const_cast <ClusterData *>( clusterSettings );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_CONNECTING ) 
        + clusterSettingsCopy->hosts[machineName].connectionIP );

    // note that we are not responsible for freeing this pointer
    // though if the removeClusterIP fails then we do need to free it.
    // TODO
    MNLBNetCfg* p_nlbNetCfg = new MNLBNetCfg( 
        clusterSettingsCopy->hosts[machineName].connectionIP,
        clusterSettingsCopy->hosts[machineName].hp.nicInfo.fullNicName
        );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE ) );
    
    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_REMOVING_CL_IP ) + clusterSettingsCopy->cp.cIP );

    // remove cluster ip from machine specified.

    p_nlbNetCfg->removeClusterIP( 
        clusterSettingsCopy->cp.cIP );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE ) );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_UNBINDING_NLB ) + clusterSettingsCopy->hosts[machineName].hp.nicInfo.fullNicName );

    AfxBeginThread( (AFX_THREADPROC ) UnbindThread,
                    p_nlbNetCfg );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_REQUEST ) );

    return CommonNLB_SUCCESS;
}

CommonNLB::CommonNLB_Error
CommonNLB::runControlMethodOnCluster( const ClusterData* clusterSettings,
                                      DataSinkI*         dataSinkObj,
                                      const _bstr_t&     methodToRun,
                                      unsigned long      portToAffect )
{
    map<_bstr_t, HostData>::iterator top;

    for( top = clusterSettings->hosts.begin();
         top != clusterSettings->hosts.end();
         ++top )
    {
        runControlMethodOnHost( clusterSettings,
                                (*top).first,
                                dataSinkObj, 
                                methodToRun,
                                portToAffect );
    }

    return CommonNLB_SUCCESS;
}


CommonNLB::CommonNLB_Error
CommonNLB::runControlMethodOnHost( const ClusterData*       clusterSettings,
                                   const _bstr_t&           machineName,
                                   DataSinkI*               dataSinkObj,
                                   const _bstr_t&           methodToRun,
                                   unsigned long            portToAffect )
{
    ClusterData* clusterSettingsCopy = 
        const_cast <ClusterData *>( clusterSettings );

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_CONNECTING ) 
        + clusterSettingsCopy->hosts[machineName].connectionIP );


    MNLBMachine nlbMachine( 
        clusterSettingsCopy->hosts[machineName].connectionIP,
        clusterSettingsCopy->cp.cIP );        

    dataSinkObj->dataSink( 
        GETRESOURCEIDSTRING( IDS_INFO_DONE ) );

    unsigned long retVal;
    
    if( methodToRun == _bstr_t( L"query" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_QUERY ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );
        
        // the hoststatus has the current state of the host.
        HostProperties hp;
        nlbMachine.getHostProperties( &hp );
        retVal = hp.hostStatus;

    }
    else if( methodToRun == _bstr_t( L"start" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_START ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.start( Common::THIS_HOST, &retVal );
    }
    else if( methodToRun == _bstr_t( L"stop" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_STOP ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.stop( Common::THIS_HOST, &retVal );
    }
    else if( methodToRun == _bstr_t( L"drainstop" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_DRAINSTOP ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.drainstop( Common::THIS_HOST, &retVal );
    }
    else if( methodToRun == _bstr_t( L"resume" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_RESUME ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.resume( Common::THIS_HOST, &retVal );
    }
    else if( methodToRun == _bstr_t( L"suspend" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_SUSPEND ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.suspend( Common::THIS_HOST, &retVal );
    }
    else if( methodToRun == _bstr_t( L"enable" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_ENABLE ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.enable( Common::THIS_HOST, &retVal, portToAffect );
    }
    else if( methodToRun == _bstr_t( L"disable" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_DISABLE ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.disable( Common::THIS_HOST, &retVal, portToAffect );
    }
    else if( methodToRun == _bstr_t( L"drain" ) )
    {
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_COMMAND_DRAIN ) +  clusterSettingsCopy->cp.cIP + L":" + machineName );

        nlbMachine.drain( Common::THIS_HOST, &retVal, portToAffect );
    }
    else
    {
        // unknown method.  It has to be one of above.
        dataSinkObj->dataSink( 
            GETRESOURCEIDSTRING( IDS_WLBS_UNKNOWN ) ); 
    }

    // decipher the return.
    _bstr_t errString;
    getWLBSErrorString( retVal,
                        errString );
    
    dataSinkObj->dataSink( errString );

    return CommonNLB_SUCCESS;
}



// the unbinding is done in a separate thread
// as this call though successful, unloads and reloads the nic
// when nlb is unbound which can cause the connection to fail.
// This failure can occur after a very long time, which causes nlb
// manager to hang if this operation is not carried out in
// separate thread.
// Also note that the ownership of the MNLBNetCfg object is given
// to this thread, thus it is deleting this object.  Thus caller
// needs to create the object on the heap, pass it in AfxBeginThread
// and be sure to not delete it.
UINT
CommonNLB::UnbindThread( LPVOID pParam )
{
    MUsingCom com;

    MNLBNetCfg* p_nlbNetCfg = ( MNLBNetCfg *) pParam;

    try
    {
        p_nlbNetCfg->unbind();
    }
    catch( _com_error (e ) )
    {
        // the above call may fail, thus we want 
        // to catch exception.
    }

    delete p_nlbNetCfg;

    return 0;
}

CommonNLB::CommonNLB_Error
CommonNLB::getWLBSErrorString( unsigned long     errStatus,      // IN
                               _bstr_t&          extErrString    // OUT
                               )
{
    switch( errStatus )
    {

        case 1000 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_OK );
            break;

        case 1001 :
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_ALREADY );
            break;

        case 1002 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_DRAIN_STOP );
            break;

        case 1003 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_BAD_PARAMS );
            break;

        case 1004 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_NOT_FOUND );
            break;

        case 1005 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_STOPPED );
            break;


        case 1006 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_CONVERGING );
            break;

        case 1007 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_CONVERGED );
            break;

        case 1008 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_DEFAULT );
            break;

        case 1009 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_DRAINING );
            break;

        case 1013 :
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_SUSPENDED );
            break;

        case 1050 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_REBOOT );
            break;

        case 1100 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_INIT_ERROR );
            break;

        case 1101 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_BAD_PASSW );
            break;

        case 1102: 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_IO_ERROR );
            break;
            
        case 1103 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_TIMEOUT );
            break;

        case 1150 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_PORT_OVERLAP );
            break;

        case 1151 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_BAD_PORT_PARAMS );
            break;

        case 1152 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_MAX_PORT_RULES );
            break;

        case 1153 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_TRUNCATED );
            break;

        case 1154 : 
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_REG_ERROR );
            break;

        default :
            extErrString = GETRESOURCEIDSTRING( IDS_WLBS_UNKNOWN ); 
            break;
    }

    return CommonNLB_SUCCESS;
}


CommonNLB::CommonNLB_Error
CommonNLB::addHostToCluster(  const ClusterData*       clusterToAddTo,
                              const _bstr_t&           machineName,
                              DataSinkI*               dataSinkObj )
{
    ClusterData* clusterToAddToCopy = 
        const_cast <ClusterData *>( clusterToAddTo );

    MNLBNetCfg* p_nlbNetCfg = NULL;
    BindAndConfigureParameters* par = NULL; 

    try {
        p_nlbNetCfg = new MNLBNetCfg(clusterToAddToCopy->hosts[machineName].connectionIP,
                                     clusterToAddToCopy->hosts[machineName].hp.nicInfo.fullNicName
                                    );

        par = new BindAndConfigureParameters;

        g_leftView = (LeftView *) dataSinkObj;

        par->nlbNetCfg = p_nlbNetCfg;
        par->clusterData = NULL;
        par->machineName = NULL;
        par->clusterData = new ClusterData( *clusterToAddToCopy );
        par->machineName = new _bstr_t( machineName );
    }
    catch(...)
    {
        if (par != NULL)
        {
            delete  par->machineName;
            delete  par->clusterData;
            delete  par;
        }
        delete  p_nlbNetCfg;

        dataSinkObj->dataSink(GETRESOURCEIDSTRING(IDS_INFO_NEW_EXCEPTION));
        throw;
    }

    AfxBeginThread( (AFX_THREADPROC ) BindAndConfigureThread,
                    par );

    return CommonNLB_SUCCESS;
}

// the binding and configuration is done in a separate thread
// as this call though successful, unloads and reloads the nic
// when nlb is bound which can cause the connection to fail.
// This failure can occur after a very long time, which causes nlb
// manager to hang if this operation is not carried out in
// separate thread.
// It is very important to ensure that you are completely sure
// that binding and configuration will succeed as this call will 
// run in its separate thread and does not generate errors even if
// failure occurs.
//
// Also note that the ownership of the MNLBNetCfg object is given
// to this thread, thus it is deleting this object.  Thus caller
// needs to create the object on the heap, pass it in AfxBeginThread
// and be sure to not delete it.
UINT
CommonNLB::BindAndConfigureThread( LPVOID pParam )
{
    MUsingCom com;

    BindAndConfigureParameters* parameters = 
        ( BindAndConfigureParameters *) pParam;

    MNLBNetCfg* p_nlbNetCfg = parameters->nlbNetCfg;

    ClusterData* p_clusterData = parameters->clusterData;

    _bstr_t* p_machineName = parameters->machineName;

    try
    {
        p_nlbNetCfg->bindAndConfigure( 
            p_clusterData,
            *p_machineName );
    }
    catch( _com_error (e ) )
    {
        // the above call may fail, thus we want 
        // to catch exception.
    }

    delete p_nlbNetCfg;
    delete p_clusterData;
    delete p_machineName;

    delete parameters;

    return 0;
}

// the modification of cluster properties is done in a separate thread
// as this call though successful, might unload and reload the nic driver
// when nlb is bound which can cause the connection to fail.
// This failure can occur after a very long time, which causes nlb
// manager to hang if this operation is not carried out in
// separate thread.
// It is very important to ensure that you are completely sure
// that this operation will succeed as this call will 
// run in its separate thread and does not generate errors even if
// failure occurs.
//
// Also note that the ownership of the MNLBNetCfg object is given
// to this thread, thus it is deleting this object.  Thus caller
// needs to create the object on the heap, pass it in AfxBeginThread
// and be sure to not delete it.
UINT
CommonNLB::ModifyClusterPropertiesThread( LPVOID pParam )
{
    MUsingCom com;

    ModifyClusterPropertiesParameters* parameters = 
        ( ModifyClusterPropertiesParameters *) pParam;

    MNLBNetCfg* p_nlbNetCfg = parameters->nlbNetCfg;

    ClusterProperties* p_clusterProperties = &(parameters->clusterData->cp);

    try
    {
        p_nlbNetCfg->modifyClusterProperties(p_clusterProperties);
    }
    catch( _com_error (e ) )
    {
        // the above call may fail, thus we want 
        // to catch exception.
    }

    delete p_nlbNetCfg;
    delete parameters->clusterData;

    delete parameters;

    return 0;
}




UINT
CommonNLB::DummyThread( LPVOID pParam )
{
    MUsingCom com;

    Sleep( 1000 );

    BindAndConfigureParameters* parameters = 
        ( BindAndConfigureParameters *) pParam;

    LeftView * leftView = g_leftView;

    TVINSERTSTRUCT item;
    item.hParent = leftView->GetTreeCtrl().GetRootItem();

    ClusterData* p_clusterDataItem;
    HTREEITEM hNextItem;
    HTREEITEM hChildItem;

    if( leftView->GetTreeCtrl().ItemHasChildren( leftView->GetTreeCtrl().GetRootItem() ) ) 
    {
        hChildItem = leftView->GetTreeCtrl().GetChildItem(leftView->GetTreeCtrl().GetRootItem() );
            
        while (hChildItem != NULL)
        {
            hNextItem = leftView->GetTreeCtrl().GetNextItem(hChildItem, TVGN_NEXT);

            p_clusterDataItem = ( ClusterData * ) leftView->GetTreeCtrl().GetItemData( hChildItem );
            
            if( p_clusterDataItem->cp.cIP == parameters->clusterData->cp.cIP )
            {
                // the cluster is found.
                
                // get the exact host.  Change icon of this host.
                hChildItem = leftView->GetTreeCtrl().GetChildItem( hChildItem );
                while( hChildItem != NULL )
                {
                    hNextItem = leftView->GetTreeCtrl().GetNextItem(hChildItem, TVGN_NEXT);
                    _bstr_t* machineName = (_bstr_t *) leftView->GetTreeCtrl().GetItemData( hChildItem );
                    if( *( machineName ) == *(parameters->machineName) )
                    {
                        // found machine to change icon of.
                        leftView->GetTreeCtrl().SetItemImage( hChildItem, 5, 5 );
                        goto outofloop;
                    }

                    hChildItem = hNextItem;
                }
            }
            
            hChildItem = hNextItem;
        }
    }

outofloop:

    // loop for around let us say 1 minute.
    // enable the icon.
    Sleep( 10000 );

    leftView->GetTreeCtrl().SetItemImage( hChildItem, 2, 2 );

    return 0;
}