//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2000-2001 Microsoft Corporation
//
//  Module Name:
//      CEnumClusCfgNetworks.cpp
//
//  Description:
//      This file contains the definition of the CEnumClusCfgNetworks
//       class.
//
//      The class CEnumClusCfgNetworks is the enumeration of cluster
//      networks. It implements the IEnumClusCfgNetworks interface.
//
//  Documentation:
//
//  Header File:
//      CEnumClusCfgNetworks.h
//
//  Maintained By:
//      Galen Barbee (GalenB) 23-FEB-2000
//
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
// Include Files
//////////////////////////////////////////////////////////////////////////////
#include "pch.h"
#include <PropList.h>
#include "CEnumClusCfgNetworks.h"
#include "CClusCfgNetworkInfo.h"


//////////////////////////////////////////////////////////////////////////////
// Constant Definitions
//////////////////////////////////////////////////////////////////////////////

DEFINE_THISCLASS( "CEnumClusCfgNetworks" );


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks class
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::S_HrCreateInstance
//
//  Description:
//      Create a CEnumClusCfgNetworks instance.
//
//  Arguments:
//      None.
//
//  Return Values:
//      Pointer to CEnumClusCfgNetworks instance.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::S_HrCreateInstance( IUnknown ** ppunkOut )
{
    TraceFunc( "" );

    HRESULT                 hr;
    CEnumClusCfgNetworks *  lpccs = NULL;

    if ( ppunkOut == NULL )
    {
        hr = THR( E_POINTER );
        goto Cleanup;
    } // if:

    lpccs = new CEnumClusCfgNetworks();
    if ( lpccs == NULL )
    {
        hr = THR( E_OUTOFMEMORY );
        goto Cleanup;
    } // if: error allocating object

    hr = THR( lpccs->HrInit() );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if: HrInit() failed

    hr = THR( lpccs->TypeSafeQI( IUnknown, ppunkOut ) );

Cleanup:

    if ( FAILED( hr ) )
    {
        LogMsg( L"[SRV] CEnumClusCfgNetworks::S_HrCreateInstance() failed. (hr = %#08x)", hr );
    } // if:

    if ( lpccs != NULL )
    {
        lpccs->Release();
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::S_HrCreateInstance


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::CEnumClusCfgNetworks
//
//  Description:
//      Constructor of the CEnumClusCfgNetworks class. This initializes
//      the m_cRef variable to 1 instead of 0 to account of possible
//      QueryInterface failure in DllGetClassObject.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CEnumClusCfgNetworks::CEnumClusCfgNetworks( void )
    : m_cRef( 1 )
    , m_lcid( LOCALE_NEUTRAL )
    , m_fLoadedNetworks( false )
{
    TraceFunc( "" );

    // Increment the count of components in memory so the DLL hosting this
    // object cannot be unloaded.
    InterlockedIncrement( &g_cObjects );

    Assert( m_picccCallback ==  NULL );
    Assert( m_pIWbemServices == NULL );
    Assert( m_prgNetworks == NULL );
    Assert( m_idxNext == 0 );
    Assert( m_idxEnumNext == 0 );
    Assert( m_bstrNodeName == NULL );
    Assert( m_cNetworks == 0 );

    TraceFuncExit();

} //*** CEnumClusCfgNetworks::CEnumClusCfgNetworks


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::~CEnumClusCfgNetworks
//
//  Description:
//      Desstructor of the CEnumClusCfgNetworks class.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CEnumClusCfgNetworks::~CEnumClusCfgNetworks( void )
{
    TraceFunc( "" );

    ULONG   idx;

    if ( m_pIWbemServices != NULL )
    {
        m_pIWbemServices->Release();
    } // if:

    if ( m_picccCallback != NULL )
    {
        m_picccCallback->Release();
    } // if:

    for ( idx = 0; idx < m_idxNext; idx++ )
    {
        ((*m_prgNetworks)[ idx ])->Release();
    } // for:

    TraceFree( m_prgNetworks );
    TraceSysFreeString( m_bstrNodeName );

    // There's going to be one less component in memory. Decrement component count.
    InterlockedDecrement( &g_cObjects );

    TraceFuncExit();

} //*** CEnumClusCfgNetworks::~CEnumClusCfgNetworks


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks -- IUknkown interface.
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  STDMETHODIMP_( ULONG )
//  CEnumClusCfgNetworks:: [IUNKNOWN] AddRef
//
//  Description:
//      Increment the reference count of this object by one.
//
//  Arguments:
//      None.
//
//  Return Value:
//      The new reference count.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CEnumClusCfgNetworks::AddRef( void )
{
    TraceFunc( "[IUnknown]" );

    InterlockedIncrement( &m_cRef );

    RETURN(  m_cRef );

} //*** CEnumClusCfgNetworks::AddRef


//////////////////////////////////////////////////////////////////////////////
//++
//
//  STDMETHODIMP_( ULONG )
//  CEnumClusCfgNetworks:: [IUNKNOWN] Release
//
//  Description:
//      Decrement the reference count of this object by one.
//
//  Arguments:
//      None.
//
//  Return Value:
//      The new reference count.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CEnumClusCfgNetworks::Release( void )
{
    TraceFunc( "[IUnknown]" );

    LONG    cRef;

    cRef = InterlockedDecrement( &m_cRef );
    if ( cRef == 0 )
    {
        TraceDo( delete this );
    } // if: reference count equal to zero

    RETURN( cRef );

} //*** CEnumClusCfgNetworks::Release


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:: [INKNOWN] QueryInterface
//
//  Description:
//      Query this object for the passed in interface.
//
//  Arguments:
//      IN  REFIID  riid,
//          Id of interface requested.
//
//      OUT void ** ppv
//          Pointer to the requested interface.
//
//  Return Value:
//      S_OK
//          If the interface is available on this object.
//
//      E_NOINTERFACE
//          If the interface is not available.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::QueryInterface( REFIID  riid, void ** ppv )
{
    TraceQIFunc( riid, ppv );

    HRESULT hr = E_NOINTERFACE;

    if ( IsEqualIID( riid, IID_IUnknown ) )
    {
         *ppv = static_cast< IEnumClusCfgNetworks * >( this );
         hr = S_OK;
    } // if: IUnknown
    else if ( IsEqualIID( riid, IID_IEnumClusCfgNetworks ) )
    {
        *ppv = TraceInterface( __THISCLASS__, IEnumClusCfgNetworks, this, 0 );
        hr   = S_OK;
    } // else if:
    else if ( IsEqualIID( riid, IID_IClusCfgWbemServices ) )
    {
        *ppv = TraceInterface( __THISCLASS__, IClusCfgWbemServices, this, 0 );
        hr   = S_OK;
    } // else if:
    else if ( IsEqualIID( riid, IID_IClusCfgInitialize ) )
    {
        *ppv = TraceInterface( __THISCLASS__, IClusCfgInitialize, this, 0 );
        hr   = S_OK;
    } // else if:

    if ( SUCCEEDED( hr ) )
    {
        ((IUnknown *) *ppv)->AddRef( );
    } // if: success

     QIRETURN_IGNORESTDMARSHALLING( hr, riid );

} //*** CEnumClusCfgNetworks::QueryInterface


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks -- IClusCfgWbemServices interface.
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::SetWbemServices
//
//  Description:
//      Set the WBEM services provider.
//
//  Arguments:
//    IN  IWbemServices  pIWbemServicesIn
//
//  Return Value:
//      S_OK
//          Success
//
//      E_POINTER
//          The pIWbemServicesIn param is NULL.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::SetWbemServices( IWbemServices * pIWbemServicesIn )
{
    TraceFunc( "[IClusCfgWbemServices]" );

    HRESULT hr = S_OK;

    if ( pIWbemServicesIn == NULL )
    {
        hr = THR( E_POINTER );
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_SetWbemServices_Enum_Networks, IDS_ERROR_NULL_POINTER, hr );
        goto Cleanup;
    } // if:

    m_pIWbemServices = pIWbemServicesIn;
    m_pIWbemServices->AddRef();

Cleanup:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::SetWbemServices


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks -- IClusCfgInitialize interface.
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Initialize
//
//  Description:
//      Initialize this component.
//
//  Arguments:
//    IN  IUknown * punkCallbackIn
//
//    IN  LCID      lcidIn
//
//  Return Value:
//      S_OK
//          Success
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Initialize(
    IUnknown *  punkCallbackIn,
    LCID        lcidIn
    )
{
    TraceFunc( "[IClusCfgInitialize]" );
    Assert( m_picccCallback == NULL );

    HRESULT hr = S_OK;

    m_lcid = lcidIn;

    if ( punkCallbackIn == NULL )
    {
        hr = THR( E_POINTER );
        goto Cleanup;
    } // if:

    hr = THR( punkCallbackIn->TypeSafeQI( IClusCfgCallback, &m_picccCallback ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    hr = THR( HrGetComputerName( ComputerNameNetBIOS, &m_bstrNodeName ) );

Cleanup:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Initialize


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks -- IEnumClusCfgNetworks interface.
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Next
//
//  Description:
//
//  Arguments:
//
//  Return Value:
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Next(
    ULONG                   cNumberRequestedIn,
    IClusCfgNetworkInfo **  rgpNetworkInfoOut,
    ULONG *                 pcNumberFetchedOut
    )
{
    TraceFunc( "[IEnumClusCfgNetworks]" );

    HRESULT                 hr = S_FALSE;
    ULONG                   cFetched = 0;
    ULONG                   idx;
    IClusCfgNetworkInfo *   pccni;

    if ( rgpNetworkInfoOut == NULL )
    {
        hr = THR( E_POINTER );
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_Next_Enum_Networks, IDS_ERROR_NULL_POINTER, hr );
        goto Cleanup;
    } // if:

    if ( !m_fLoadedNetworks )
    {
        hr = THR( HrGetNetworks() );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:
    } // if:

    Assert( m_prgNetworks != NULL );
    Assert( m_idxNext > 0 );

    cFetched = min( cNumberRequestedIn, ( m_idxNext - m_idxEnumNext ) );

    for ( idx = 0; idx < cFetched; idx++, m_idxEnumNext++ )
    {
        hr = THR( ((*m_prgNetworks)[ m_idxEnumNext ])->TypeSafeQI( IClusCfgNetworkInfo, &pccni ) );
        if ( FAILED( hr ) )
        {
            break;
        } // if:

        rgpNetworkInfoOut[ idx ] = pccni;

    } // for:

    if ( FAILED( hr ) )
    {
        ULONG   idxStop = idx;

        m_idxEnumNext -= idx;

        for ( idx = 0; idx < idxStop; idx++ )
        {
            (rgpNetworkInfoOut[ idx ])->Release();
        } // for:

        cFetched = 0;

        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_Next_Failed, IDS_ERROR_NETWORK_ENUM, hr );

        goto Cleanup;
    } // if:

    if ( cFetched < cNumberRequestedIn )
    {
        hr = S_FALSE;
    } // if:

Cleanup:

    if ( pcNumberFetchedOut != NULL )
    {
        *pcNumberFetchedOut = cFetched;
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Next


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Skip
//
//  Description:
//
//  Arguments:
//
//  Return Value:
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Skip( ULONG cNumberToSkipIn )
{
    TraceFunc( "[IEnumClusCfgNetworks]" );

    HRESULT hr = S_OK;

    m_idxEnumNext += cNumberToSkipIn;
    if ( m_idxEnumNext >= m_idxNext )
    {
        m_idxEnumNext = m_idxNext;
        hr = STHR( S_FALSE );
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Skip


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Reset
//
//  Description:
//
//  Arguments:
//
//  Return Value:
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Reset( void )
{
    TraceFunc( "[IEnumClusCfgNetworks]" );

    HRESULT hr = S_OK;

    m_idxEnumNext = 0;

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Reset


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Clone
//
//  Description:
//
//  Arguments:
//
//  Return Value:
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Clone(
    IEnumClusCfgNetworks ** ppEnumNetworksOut
    )
{
    TraceFunc( "[IEnumClusCfgNetworks]" );

    HRESULT hr = S_OK;

    if ( ppEnumNetworksOut == NULL )
    {
        hr = THR( E_POINTER );
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_Clone_Enum_Networks, IDS_ERROR_NULL_POINTER, hr );
        goto Cleanup;
    } // if:

    hr = THR( E_NOTIMPL );

Cleanup:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Clone


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::Count
//
//  Description:
//
//  Arguments:
//
//  Return Value:
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CEnumClusCfgNetworks::Count( DWORD * pnCountOut )
{
    TraceFunc( "[IEnumClusCfgNetworks]" );

    HRESULT hr = S_OK;

    if ( pnCountOut == NULL )
    {
        hr = THR( E_POINTER );
        goto Cleanup;
    } // if:

    if ( !m_fLoadedNetworks )
    {
        hr = THR( HrGetNetworks() );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:
    } // if:

    *pnCountOut = m_cNetworks;

Cleanup:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::Count


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// CEnumClusCfgNetworks class -- Private Methods.
/////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::HrInit
//
//  Description:
//      Initialize this component.
//
//  Arguments:
//      None.
//
//  Return Value:
//
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrInit( void )
{
    TraceFunc( "" );

    HRESULT hr = S_OK;

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrInit


/////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::HrGetNetworks
//
//  Description:
//
//  Arguments:
//
//
//  Return Value:
//
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrGetNetworks( void )
{
    TraceFunc( "" );

    HRESULT                 hr = S_FALSE;
    BSTR                    bstrQuery = NULL;
    BSTR                    bstrWQL = NULL;
    BSTR                    bstrAdapterQuery = NULL;
    IEnumWbemClassObject *  pNetworks = NULL;
    ULONG                   ulReturned;
    IWbemClassObject *      pNetwork = NULL;
    IWbemClassObject *      pAdapterInfo = NULL;
    VARIANT                 varConnectionStatus;
    VARIANT                 varConnectionID;
    VARIANT                 varName;
    VARIANT                 varIndex;
    VARIANT                 varDHCPEnabled;
    DWORD                   sc;
    DWORD                   dwState;

    sc = TW32( GetNodeClusterState( NULL, &dwState ) );
    if ( sc != ERROR_SUCCESS )
    {
        hr = HRESULT_FROM_WIN32( sc );
        goto Cleanup;
    } // if:

    if ( dwState == ClusterStateRunning )
    {
        hr = THR( HrLoadClusterNetworks() );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:
    } // if:

    VariantInit( &varConnectionStatus );
    VariantInit( &varConnectionID );
    VariantInit( &varName );
    VariantInit( &varIndex );
    VariantInit( &varDHCPEnabled );

    bstrWQL = TraceSysAllocString( L"WQL" );
    if ( bstrWQL == NULL )
    {
        goto OutOfMemory;
    } // if:

    bstrQuery = TraceSysAllocString( L"Select * from Win32_NetworkAdapter where AdapterTypeID=0 or AdapterTypeID=1 or AdapterTypeID=5" );
    if ( bstrQuery == NULL )
    {
        goto OutOfMemory;
    } // if:

    hr = THR( m_pIWbemServices->ExecQuery( bstrWQL, bstrQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &pNetworks ) );
    if ( FAILED( hr ) )
    {
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_WMI_NetworkAdapter_Qry_Failed, IDS_ERROR_WMI_NETWORKADAPTER_QRY_FAILED, hr );
        goto Cleanup;
    } // if:

    for ( ; ; )
    {
        hr = pNetworks->Next( WBEM_INFINITE, 1, &pNetwork, &ulReturned );
        if ( ( hr == S_OK ) && ( ulReturned == 1 ) )
        {
            //
            //  Get the adapter name.  We will need this for checking for NLBS and in the warning for when
            //  we are skipping an adapter.
            //
            hr = THR( HrGetWMIProperty( pNetwork, L"Name", VT_BSTR, &varName ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            //
            //  Is this adapter the soft NLBS adapter?  If it is then skip it.
            //
            hr = STHR( HrIsNLBS( varName.bstrVal, pNetwork ) );
            if ( hr == S_OK )
            {
                continue;
            } // if:
            else if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // else if:

            //
            //  Get the NetConnectionID.  Only "real" hardware adapters will have this as a non-NULL property.
            //
            hr = HrGetWMIProperty( pNetwork, L"NetConnectionID", VT_BSTR, &varConnectionID );
            if ( ( hr == E_PROPTYPEMISMATCH ) && ( varConnectionID.vt == VT_NULL ) )
            {
                hr = S_FALSE;
                STATUS_REPORT_STRING( TASKID_Major_Find_Devices, TASKID_Minor_HrGetNetworks_Skipped, IDS_WARNING_NETWORK_SKIPPED, varName.bstrVal, hr );

                continue;       // skip this adapter
            } // if:
            else if ( FAILED( hr ) )
            {
                THR( hr );
                goto Cleanup;
            } // else if:

            //
            //  Check the connection status of this adapter and skip it if it is not connected.
            //
            hr = THR( HrGetWMIProperty( pNetwork, L"NetConnectionStatus", VT_I4, &varConnectionStatus ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            //
            //  If the network adapter is not connected then skip it.
            //
            if ( varConnectionStatus.iVal != STATUS_CONNECTED )
            {
                hr = S_FALSE;
                STATUS_REPORT_STRING2(
                    TASKID_Major_Find_Devices,
                    TASKID_Minor_HrGetNetworks_NotConnected,
                    IDS_WARNING_NETWORK_NOT_CONNECTED,
                    varConnectionID.bstrVal,
                    varConnectionStatus.iVal,
                    hr
                    );

                pNetwork->Release();
                pNetwork = NULL;
                continue;
            } // if:

            //
            // Get the Index No. of this adapter
            //
            hr = THR( HrGetWMIProperty( pNetwork, L"Index", VT_I4, &varIndex ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            //
            // Get the associated NetworkAdapterConfiguration WMI object. First, format the Query string
            //
            hr = HrFormatStringIntoBSTR(
                L"Win32_NetworkAdapterConfiguration.Index=%1!u!",
                &bstrAdapterQuery,
                varIndex.iVal
                );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            }

            //
            // Then, get the Object
            //
            hr = THR( m_pIWbemServices->GetObject( 
                bstrAdapterQuery,
                WBEM_FLAG_RETURN_WBEM_COMPLETE,
                NULL,
                &pAdapterInfo,
                NULL
                ) );
            if ( FAILED ( hr ) )
            {
                goto Cleanup;
            } // if:

            TraceSysFreeString( bstrAdapterQuery );
            bstrAdapterQuery = NULL;

            //
            // Find out if this adapter is DHCP enabled. If it is, send out a warning.
            //
            hr = THR( HrGetWMIProperty( pAdapterInfo, L"DHCPEnabled", VT_BOOL, &varDHCPEnabled ) );
            if ( FAILED ( hr ) )
            {
                goto Cleanup;
            } // if:

            if ( ( varDHCPEnabled.vt == VT_BOOL ) && ( varDHCPEnabled.boolVal == VARIANT_TRUE ) )
            {
                hr = S_FALSE;
                STATUS_REPORT_STRING(
                    TASKID_Major_Find_Devices,
                    TASKID_Minor_HrGetNetworks_DHCP_Enabled,
                    IDS_WARNING_DHCP_ENABLED,
                    varConnectionID.bstrVal,
                    hr
                    );
                if ( FAILED ( hr ) )
                {
                    goto Cleanup;
                }
            } // if:

            pAdapterInfo->Release();
            pAdapterInfo = NULL;

            hr = STHR( HrCreateAndAddNetworkToArray( pNetwork ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            pNetwork->Release();
            pNetwork = NULL;
        } // if:
        else if ( ( hr == S_FALSE ) && ( ulReturned == 0 ) )
        {
            hr = S_OK;
            break;
        } // else if:
        else
        {
            STATUS_REPORT_STRING( TASKID_Major_Find_Devices, TASKID_Minor_WQL_Network_Qry_Next_Failed, IDS_ERROR_WQL_QRY_NEXT_FAILED, bstrQuery, hr );
            goto Cleanup;
        } // else:
    } // for:

    m_idxEnumNext = 0;
    m_fLoadedNetworks = TRUE;

    goto Cleanup;

OutOfMemory:

    hr = THR( E_OUTOFMEMORY );
    STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_HrGetNetworks, IDS_ERROR_OUTOFMEMORY, hr );

Cleanup:

    VariantClear( &varConnectionStatus );
    VariantClear( &varConnectionID );
    VariantClear( &varName );
    VariantClear( &varIndex );
    VariantClear( &varDHCPEnabled );

    TraceSysFreeString( bstrQuery );
    TraceSysFreeString( bstrWQL );
    TraceSysFreeString( bstrAdapterQuery );

    if ( pNetwork != NULL )
    {
        pNetwork->Release();
    } // if:

    if ( pNetworks != NULL )
    {
        pNetworks->Release();
    } // if:

    if ( pAdapterInfo != NULL )
    {
        pAdapterInfo->Release();
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrGetNetworks


/////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:HrAddNetworkToArray
//
//  Description:
//      Add the passed in Network to the array of punks that holds the Networks.
//
//  Arguments:
//
//
//  Return Value:
//      S_OK
//          Success
//
//      E_OUTOFMEMORY
//          Couldn't allocate memeory.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrAddNetworkToArray( IUnknown * punkIn )
{
    TraceFunc( "" );

    HRESULT     hr = S_OK;
    IUnknown *  ((*prgpunks)[]) = NULL;

    prgpunks = (IUnknown *((*)[])) TraceReAlloc( m_prgNetworks, sizeof( IUnknown * ) * ( m_idxNext + 1 ), HEAP_ZERO_MEMORY );
    if ( prgpunks == NULL )
    {
        hr = THR( E_OUTOFMEMORY );
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_HrAddNetworkToArray, IDS_ERROR_OUTOFMEMORY, hr );
        goto Cleanup;
    } // if:

    m_prgNetworks = prgpunks;

    (*m_prgNetworks)[ m_idxNext++ ] = punkIn;
    punkIn->AddRef();
    m_cNetworks += 1;

Cleanup:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrAddNetworkToArray


/////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::HrCreateAndAddNetworkToArray
//
//  Description:
//      Create a IClusCfgStorageDevice object and add the passed in Network to
//      the array of punks that holds the Networks.
//
//  Arguments:
//
//
//  Return Value:
//      S_OK
//          Success
//
//      E_OUTOFMEMORY
//          Couldn't allocate memeory.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrCreateAndAddNetworkToArray(
    IWbemClassObject * pNetworkIn
    )
{
    TraceFunc( "" );

    HRESULT                 hr = S_FALSE;
    IUnknown *              punk = NULL;
    IClusCfgSetWbemObject * piccswo = NULL;
    bool                    fRetainObject = true;

    hr = THR( CClusCfgNetworkInfo::S_HrCreateInstance( &punk ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    punk = TraceInterface( L"CClusCfgNetworkInfo", IUnknown, punk, 1 );

    hr = THR( HrSetInitialize( punk, m_picccCallback, m_lcid ) );
    if ( FAILED( hr ))
    {
        goto Cleanup;
    } // if:

    hr = THR( HrSetWbemServices( punk, m_pIWbemServices ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    hr = THR( punk->TypeSafeQI( IClusCfgSetWbemObject, &piccswo ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    hr = STHR( piccswo->SetWbemObject( pNetworkIn, &fRetainObject ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    if ( ( hr == S_OK ) && ( fRetainObject ) )
    {
        hr = STHR( HrIsThisNetworkUnique( punk, pNetworkIn ) );
        if ( hr == S_OK )
        {
            hr = THR( HrAddNetworkToArray( punk ) );
        } // if:
    } // if:

Cleanup:

    if ( piccswo != NULL )
    {
        piccswo->Release();
    } // if:

    if ( punk != NULL )
    {
        punk->Release();
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrCreateAndAddNetworkToArray


/////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:HrIsThisNetworkUnique
//
//  Description:
//      Does a network for this IP Address and subnet already exist?
//
//  Arguments:
//
//
//  Return Value:
//      S_OK
//          Success
//
//      S_FALSE
//          This network is a duplicate.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrIsThisNetworkUnique(
    IUnknown *          punkIn,
    IWbemClassObject *  pNetworkIn
    )
{
    TraceFunc( "" );
    Assert( punkIn != NULL );

    HRESULT                         hr = S_OK;
    ULONG                           idx;
    IClusCfgNetworkInfo *           piccni = NULL;
    IClusCfgNetworkInfo *           piccniSource = NULL;
    BSTR                            bstr = NULL;
    BSTR                            bstrSource = NULL;
    BSTR                            bstrAdapterName = NULL;
    BSTR                            bstrConnectionName = NULL;
    BSTR                            bstrMessage = NULL;
    VARIANT                         var;
    IClusCfgClusterNetworkInfo *    picccni = NULL;

    VariantInit( &var );

    hr = THR( punkIn->TypeSafeQI( IClusCfgNetworkInfo, &piccniSource ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    hr = THR( piccniSource->GetUID( &bstrSource ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    TraceMemoryAddBSTR( bstrSource );

    for ( idx = 0; idx < m_idxNext; idx++ )
    {
        hr = THR( ((*m_prgNetworks)[ idx ])->TypeSafeQI( IClusCfgNetworkInfo, &piccni ) );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:

        hr = THR( piccni->GetUID( &bstr ) );
        if ( FAILED( hr ) )
        {
            goto Cleanup;
        } // if:

        TraceMemoryAddBSTR( bstr );

        if ( wcscmp( bstr, bstrSource ) == 0 )
        {
            hr = THR( piccni->TypeSafeQI( IClusCfgClusterNetworkInfo, &picccni ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            hr = STHR( picccni->HrIsClusterNetwork() );
            picccni->Release();
            picccni = NULL;

            //
            //  If the network in the enum was already a cluster network then we do not need
            //  to warn the user.
            //
            if ( hr == S_OK )
            {
                hr = S_FALSE;       // tell the caller that this is a duplicate network
            } // if:
            else if ( hr == S_FALSE )       // warn the user
            {
                HRESULT hrTemp;

                hr = THR( HrGetWMIProperty( pNetworkIn, L"Name", VT_BSTR, &var ) );
                if ( FAILED( hr ) )
                {
                    bstrAdapterName = NULL;
                } // if:
                else
                {
                    bstrAdapterName = TraceSysAllocString( var.bstrVal );
                } // else:

                VariantClear( &var );

                hr = THR( HrGetWMIProperty( pNetworkIn, L"NetConnectionID", VT_BSTR, &var ) );
                if ( FAILED( hr ) )
                {
                    bstrConnectionName = NULL;
                } // if:
                else
                {
                    bstrConnectionName = TraceSysAllocString( var.bstrVal );
                } // else:

                hr = THR( HrFormatMessageIntoBSTR( g_hInstance,
                                                   IDS_ERROR_WMI_NETWORKADAPTER_DUPE_FOUND,
                                                   &bstrMessage,
                                                   bstrAdapterName != NULL ? bstrAdapterName : L"Unknown",
                                                   bstrConnectionName != NULL ? bstrConnectionName : L"Unknown"
                                                   ) );
                if ( FAILED( hr ) )
                {
                    bstrMessage = NULL;
                } // if:

                hr = S_FALSE;

                hrTemp = THR( HrSendStatusReport(
                                m_picccCallback,
                                TASKID_Major_Find_Devices,
                                TASKID_Minor_WMI_NetworkAdapter_Dupe_Found,
                                0,
                                1,
                                1,
                                hr,
                                bstrMessage != NULL ? bstrMessage : L"An adapter with a duplicate IP address and subnet was found."
                                ) );
                if ( FAILED( hrTemp ) )
                {
                    hr = hrTemp;
                    goto Cleanup;
                } // if:

            } // else if:

            break;
        } // if:

        piccni->Release();
        piccni = NULL;
    } // for:

Cleanup:

    if ( picccni != NULL )
    {
        picccni->Release();
    } // if:

    if ( piccniSource != NULL )
    {
        piccniSource->Release();
    } // if:

    if ( piccni != NULL )
    {
        piccni->Release();
    } // if:

    VariantClear( &var );

    TraceSysFreeString( bstrAdapterName );
    TraceSysFreeString( bstrConnectionName );
    TraceSysFreeString( bstrMessage );
    TraceSysFreeString( bstrSource );
    TraceSysFreeString( bstr );

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrIsThisNetworkUnique


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:HrIsNLBS
//
//  Description:
//      Is the passed in adapter the NLBS soft adapter?
//
//  Arguments:
//
//
//  Return Value:
//      S_OK
//          The adapter is the NLBS soft adapter.
//
//      S_FALSE
//          The adapter is not the NLBS soft adapter.
//
//      Other HRESULT errors.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrIsNLBS(
    BSTR                bstrNameIn,
    IWbemClassObject *  pNetworkIn
    )
{
    TraceFunc( "" );
    Assert( bstrNameIn != NULL );
    Assert( pNetworkIn != NULL );

    HRESULT hr = S_OK;
    BSTR    bstr = NULL;

    //
    //  For now doing a simple string compare on the names...
    //
    hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_NLBS_SOFT_ADAPTER_NAME, &bstr ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    if ( _wcsicmp( bstrNameIn, bstr ) == 0 )
    {
        hr = S_FALSE;
        STATUS_REPORT( TASKID_Major_Find_Devices, TASKID_Minor_Warning_NLBS_Detected, IDS_WARNING_NLBS_DETECTED, hr );
    } // if:
    else
    {
        hr = S_FALSE;
    } // else:

Cleanup:

    TraceSysFreeString( bstr );

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrIsNLBS


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:HrLoadClusterNetworks
//
//  Description:
//      Load the cluster networks.
//
//  Arguments:
//
//
//  Return Value:
//      S_OK
//          Success.
//
//      Other HRESULT errors.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrLoadClusterNetworks( void )
{
    TraceFunc( "" );

    HRESULT         hr = S_OK;
    HCLUSTER        hCluster = NULL;
    HCLUSENUM       hEnum = NULL;
    DWORD           sc;
    DWORD           idx;
    DWORD           cch = 33;
    WCHAR *         psz = NULL;
    DWORD           dwType;
    HNETWORK        hNetwork = NULL;
    BSTR            bstrNetInterfaceName = NULL;
    HNETINTERFACE   hNetInterface = NULL;

    hCluster = OpenCluster( NULL );
    if ( hCluster == NULL )
    {
        sc = TW32( GetLastError() );
        goto MakeHr;
    } // if:

    hEnum = ClusterOpenEnum( hCluster, CLUSTER_ENUM_NETWORK );
    if ( hEnum == NULL )
    {
        sc = TW32( GetLastError() );
        goto MakeHr;
    } // if:

    psz = new WCHAR [ cch ];
    if ( psz == NULL )
    {
        goto OutOfMemory;
    } // if:

    for ( idx = 0; ; )
    {
        sc = ClusterEnum( hEnum, idx, &dwType, psz, &cch );
        if ( sc == ERROR_NO_MORE_ITEMS )
        {
            break;
        } // if:

        if ( sc == ERROR_MORE_DATA )
        {
            delete [] psz;
            psz = NULL;

            cch++;
            psz = new WCHAR [ cch ];
            if ( psz == NULL )
            {
                goto OutOfMemory;
            } // if:

            continue;
        } // if:

        if ( sc == ERROR_SUCCESS )
        {
            hNetwork = OpenClusterNetwork( hCluster, psz );
            if ( hNetwork == NULL )
            {
                sc = TW32( GetLastError() );
                goto MakeHr;
            } // if:

            hr = THR( HrFindNetInterface( hNetwork, &bstrNetInterfaceName ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            hNetInterface = OpenClusterNetInterface( hCluster, bstrNetInterfaceName );
            if ( hNetInterface == NULL )
            {
                sc = TW32( GetLastError() );
                goto MakeHr;
            } // if:

            hr = THR( HrLoadClusterNetwork( hNetwork, hNetInterface ) );
            if ( FAILED( hr ) )
            {
                goto Cleanup;
            } // if:

            CloseClusterNetInterface( hNetInterface );
            hNetInterface = NULL;

            CloseClusterNetwork( hNetwork );
            hNetwork = NULL;

            TraceSysFreeString( bstrNetInterfaceName );
            bstrNetInterfaceName = NULL;

            idx++;
            continue;
        } // if:

        TW32( sc );
        goto MakeHr;

    } // for:

    goto Cleanup;

MakeHr:

    hr = HRESULT_FROM_WIN32( sc );
    goto Cleanup;

OutOfMemory:

    hr = THR( E_OUTOFMEMORY );

Cleanup:

    if ( hNetInterface != NULL )
    {
        CloseClusterNetInterface( hNetInterface );
    } // if:

    if ( hNetwork != NULL )
    {
        CloseClusterNetwork( hNetwork );
    } // if:

    if ( hEnum != NULL )
    {
        ClusterCloseEnum( hEnum );
    } // if:

    if ( hCluster != NULL )
    {
        CloseCluster( hCluster );
    } // if:

    delete [] psz;

    TraceSysFreeString( bstrNetInterfaceName );

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrLoadClusterNetworks


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks:HrLoadClusterNetwork
//
//  Description:
//      Load the cluster network and put it into the array of networks.
//
//  Arguments:
//      pszNetworkNameIn
//
//  Return Value:
//      S_OK
//          Success.
//
//      Other HRESULT errors.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrLoadClusterNetwork(
      HNETWORK      hNetworkIn
    , HNETINTERFACE hNetInterfaceIn
    )
{
    TraceFunc( "" );
    Assert( hNetworkIn != NULL );

    HRESULT     hr;
    IUnknown *  punk = NULL;
    IUnknown *  punkCallback = NULL;

    hr = THR( m_picccCallback->TypeSafeQI( IUnknown, &punkCallback ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    //
    //  Have to pass the Initialize interface arguments since new objects will
    //  be created when this call is made.
    //
    hr = THR( CClusCfgNetworkInfo::S_HrCreateInstance( hNetworkIn, hNetInterfaceIn, punkCallback, m_lcid, m_pIWbemServices, &punk ) );
    if ( FAILED( hr ) )
    {
        goto Cleanup;
    } // if:

    //
    //  This is special -- do not initialize this again.
    //
    //hr = THR( HrSetInitialize( punk, m_picccCallback, m_lcid ) );
    //if ( FAILED( hr ))
    //{
    //    goto Cleanup;
    //} // if:

    //hr = THR( HrSetWbemServices( punk, m_pIWbemServices ) );
    //if ( FAILED( hr ) )
    //{
    //    goto Cleanup;
    //} // if:

    hr = THR( HrAddNetworkToArray( punk ) );

    goto Cleanup;

Cleanup:

    if ( punkCallback != NULL )
    {
        punkCallback->Release();
    } // if:

    if ( punk != NULL )
    {
        punk->Release();
    } // if:

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrLoadClusterNetwork


//////////////////////////////////////////////////////////////////////////////
//++
//
//  CEnumClusCfgNetworks::HrFindNetInterface
//
//  Description:
//      Find the netinterface for the passed in network.
//
//  Arguments:
//      pszNetworkNameIn
//
//  Return Value:
//      S_OK
//          Success.
//
//      Other HRESULT errors.
//
//  Remarks:
//      None.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CEnumClusCfgNetworks::HrFindNetInterface(
      HNETWORK      hNetworkIn
    , BSTR *        pbstrNetInterfaceNameOut
    )
{
    TraceFunc( "" );
    Assert( hNetworkIn != NULL );
    Assert( pbstrNetInterfaceNameOut != NULL );

    HRESULT         hr = S_OK;
    DWORD           sc;
    HNETWORKENUM    hEnum = NULL;
    WCHAR *         psz = NULL;
    DWORD           cch = 33;
    DWORD           idx;
    DWORD           dwType;

    hEnum = ClusterNetworkOpenEnum( hNetworkIn, CLUSTER_NETWORK_ENUM_NETINTERFACES );
    if ( hEnum == NULL )
    {
        sc = TW32( GetLastError() );
        goto MakeHr;
    } // if:

    psz = new WCHAR [ cch ];
    if ( psz == NULL )
    {
        goto OutOfMemory;
    } // if:

    for ( idx = 0; ; )
    {
        sc = ClusterNetworkEnum( hEnum, idx, &dwType, psz, &cch );
        if ( sc == ERROR_NO_MORE_ITEMS )
        {
            break;
        } // if:

        if ( sc == ERROR_MORE_DATA )
        {
            delete [] psz;
            psz = NULL;

            cch++;
            psz = new WCHAR [ cch ];
            if ( psz == NULL )
            {
                goto OutOfMemory;
            } // if:

            continue;
        } // if:

        if ( sc == ERROR_SUCCESS )
        {
            Assert( idx < 1 );      // only expect one netinterface per network

            *pbstrNetInterfaceNameOut = TraceSysAllocString( psz );
            if ( *pbstrNetInterfaceNameOut == NULL )
            {
                goto OutOfMemory;
            } // if:

            idx++;
            continue;
        } // if:

        TW32( sc );
        goto MakeHr;
    } // for:

    goto Cleanup;

MakeHr:

    hr = HRESULT_FROM_WIN32( sc );
    goto Cleanup;

OutOfMemory:

    hr = THR( E_OUTOFMEMORY );

Cleanup:

    if ( hEnum != NULL )
    {
        ClusterNetworkCloseEnum( hEnum );
    } // if:

    delete [] psz;

    HRETURN( hr );

} //*** CEnumClusCfgNetworks::HrFindNetInterface