windows-xp/Source/XPSP1/NT/sdktools/pdh/pdhwmi/wbem.cpp

/*++

Copyright (C) 1995-1999 Microsoft Corporation

Module Name:

    wmi.c

Abstract:

    WMI interface functions exported by PDH.DLL

--*/

#include <windows.h>
#include <winperf.h>
#include "mbctype.h"
#include <mbctype.h>
#include <pdh.h>
#include <pdhmsg.h>
#include <assert.h>
#include "wbemdef.h"
#include "pdhitype.h"
#include "pdhidef.h"
#include "strings.h"

#define PERF_TIMER_FIELD \
    (PERF_TIMER_TICK | PERF_TIMER_100NS | PERF_OBJECT_TIMER)

__inline 
VOID
PdhiSysFreeString( 
    BSTR *x
) 
{
    if (x != NULL) {
        if (*x != NULL) {
            SysFreeString(*x);
            *x = NULL;
        }
    }
}

// at this point, calling the refresher while adding items to the refresher
// doesn't work. so for the time being, we'll use this interlock to prevent
// a collision
static BOOL bDontRefresh = FALSE;

// Prototype
HRESULT WbemSetProxyBlanket(
    IUnknown                 *pInterface,
    DWORD                     dwAuthnSvc,
    DWORD                     dwAuthzSvc,
    OLECHAR                  *pServerPrincName,
    DWORD                     dwAuthLevel,
    DWORD                     dwImpLevel,
    RPC_AUTH_IDENTITY_HANDLE  pAuthInfo,
    DWORD                     dwCapabilities );

HRESULT SetWbemSecurity( IUnknown *pInterface )
{
    return WbemSetProxyBlanket( pInterface, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
                RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
}


// This is the same timeout value the refresher uses so we can pretend
// we're doing the same thing.

#define WBEM_REFRESHER_TIMEOUT  10000

//  This class is designed to encapsulate the IWbemRefresher functionality
//  The definition and implementation are all in this source file

class CWbemRefresher : public IUnknown
{
protected:
    LONG                        m_lRefCount;

    // The primitives that will control the multithreading stuff
    HANDLE                      m_hQuitEvent;
    HANDLE                      m_hDoWorkEvent;
    HANDLE                      m_hWorkDoneEvent;
    HANDLE                      m_hRefrMutex;
    HANDLE                      m_hInitializedEvent;
    HANDLE                      m_hThread;
    DWORD                       m_dwThreadId;
    BOOL                        m_fThreadOk;

    // These are the pass-thru variables we will use as placeholders
    // as we perform our operations.  Note that a couple are missing.
    // This is because we are not really using them in our code, so
    // no sense in adding anything we don't really need.

    IStream*            m_pNSStream;
    LPCWSTR             m_wszPath;
    LPCWSTR             m_wszClassName;
    long                m_lFlags;
    IWbemClassObject**  m_ppRefreshable;
    IWbemHiPerfEnum**   m_ppEnum;
    long*               m_plId;
    long                m_lId;
    HRESULT             m_hOperResult;

    // This is what will be set to indicate to the thread which operation
    // it is supposed to perform.

    typedef enum
    {
        eRefrOpNone,
        eRefrOpRefresh,
        eRefrOpAddByPath,
        eRefrOpAddEnum,
        eRefrOpRemove,
        eRefrOpLast
    }   tRefrOps;

    tRefrOps            m_eRefrOp;

    // Thread ebtryt
    class XRefresher : public IWbemRefresher
    {
    protected:
        CWbemRefresher* m_pOuter;

    public:
        XRefresher( CWbemRefresher* pOuter ) : m_pOuter( pOuter ) {};
        ~XRefresher()   {};

        STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj);
        STDMETHOD_(ULONG, AddRef)(THIS);
        STDMETHOD_(ULONG, Release)(THIS);
        STDMETHOD(Refresh)(long lFlags);

    } m_xRefresher;

    class XConfigRefresher : public IWbemConfigureRefresher
    {
    protected:
        CWbemRefresher* m_pOuter;

    public:
        XConfigRefresher( CWbemRefresher* pOuter ) : m_pOuter( pOuter ) {};
        ~XConfigRefresher() {};

        STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj);
        STDMETHOD_(ULONG, AddRef)(THIS);
        STDMETHOD_(ULONG, Release)(THIS);
        STDMETHOD(AddObjectByPath)(IWbemServices* pNamespace, LPCWSTR wszPath,
            long lFlags, IWbemContext* pContext,
            IWbemClassObject** ppRefreshable, long* plId);

        STDMETHOD(AddObjectByTemplate)(IWbemServices* pNamespace,
            IWbemClassObject* pTemplate,
            long lFlags, IWbemContext* pContext,
            IWbemClassObject** ppRefreshable, long* plId);

        STDMETHOD(AddRefresher)(IWbemRefresher* pRefresher, long lFlags,
            long* plId);

        STDMETHOD(Remove)(long lId, long lFlags);

        STDMETHOD(AddEnum)( IWbemServices*  pNamespace, LPCWSTR wscClassName,
            long lFlags, IWbemContext* pContext, IWbemHiPerfEnum** ppEnum,
            long* plId );

    } m_xConfigRefresher;

protected:

    void Initialize( void );
    void Cleanup( void );

    // Operation helpers
    HRESULT SignalRefresher( void );
    HRESULT SetRefresherParams( IWbemServices* pNamespace, tRefrOps eOp,
            LPCWSTR pwszPath, LPCWSTR pwszClassName, long lFlags,
            IWbemClassObject** ppRefreshable, IWbemHiPerfEnum** ppEnum, long* plId,
            long lId );
    void ClearRefresherParams( void );

    DWORD WINAPI RealEntry( void );

    static DWORD WINAPI ThreadProc( void * pThis )
    {
        return ((CWbemRefresher*) pThis)->RealEntry();
    }

public:
    CWbemRefresher();
    virtual ~CWbemRefresher();

    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj);
    STDMETHOD_(ULONG, AddRef)(THIS);
    STDMETHOD_(ULONG, Release)(THIS);

    // The real implementations
    STDMETHOD(AddObjectByPath)(IWbemServices* pNamespace, LPCWSTR wszPath,
        long lFlags, IWbemContext* pContext,
        IWbemClassObject** ppRefreshable, long* plId);

    STDMETHOD(AddObjectByTemplate)(IWbemServices* pNamespace,
        IWbemClassObject* pTemplate,
        long lFlags, IWbemContext* pContext,
        IWbemClassObject** ppRefreshable, long* plId);

    STDMETHOD(AddRefresher)(IWbemRefresher* pRefresher, long lFlags,
        long* plId);

    STDMETHOD(Remove)(long lId, long lFlags);

    STDMETHOD(AddEnum)( IWbemServices*  pNamespace, LPCWSTR wscClassName,
        long lFlags, IWbemContext* pContext, IWbemHiPerfEnum** ppEnum,
        long* plId );

    STDMETHOD(Refresh)(long lFlags);

};

/*
**  Begin CWbemRefresher Implementation
*/

#if _MSC_VER >= 1200
#pragma warning(push)
#endif

#pragma warning(disable:4355)

// CTor and DTor
CWbemRefresher::CWbemRefresher( void )
: m_lRefCount(0), m_xRefresher( this ), m_xConfigRefresher( this ),
        m_hQuitEvent( NULL ),
        m_hDoWorkEvent( NULL ), m_hRefrMutex( NULL ), m_hInitializedEvent( NULL ),
        m_hThread( NULL ), m_hWorkDoneEvent( NULL ), m_dwThreadId( 0 ),
        m_pNSStream( NULL ), m_wszPath( NULL ), m_wszClassName( NULL ),
        m_lFlags( 0L ), m_ppRefreshable( NULL ), m_ppEnum( NULL ), m_plId( NULL ),
        m_eRefrOp( eRefrOpRefresh ), m_hOperResult( WBEM_S_NO_ERROR ), m_fThreadOk( FALSE ),
        m_lId( 0 )
{
    Initialize();
}

#if _MSC_VER >= 1200
#pragma warning(pop)
#else
#pragma warning(default:4355)
#endif

CWbemRefresher::~CWbemRefresher( void )
{
    Cleanup();
}

void CWbemRefresher::Initialize( void )
{
    // Now create the events, mutexes and our pal, the MTA thread on which all of
    // the operations will run

    m_hQuitEvent = CreateEventW( NULL, FALSE, FALSE, NULL );
    m_hDoWorkEvent = CreateEventW( NULL, FALSE, FALSE, NULL );
    m_hInitializedEvent = CreateEventW( NULL, FALSE, FALSE, NULL );
    m_hWorkDoneEvent = CreateEventW( NULL, FALSE, FALSE, NULL );

    m_hRefrMutex = CreateMutexW( NULL, FALSE, NULL );

    // If we don't have all these, something's gone south
    if (    NULL    ==  m_hQuitEvent        ||
            NULL    ==  m_hDoWorkEvent      ||
            NULL    ==  m_hInitializedEvent ||
            NULL    ==  m_hWorkDoneEvent    ||
            NULL    ==  m_hRefrMutex        )
    {
        return;
    }

    // Kick off the thread and wait for the initialized event signal (we'll give it
    // 5 seconds...if it don't get signalled in that timeframe, something is most likely
    // wrong, but we'll bounce out so whoever allocated us isn't left wondering what
    // to do).

    m_hThread = CreateThread( NULL, 0, CWbemRefresher::ThreadProc,
                    (void*) this, 0, &m_dwThreadId );

    if ( NULL == m_hThread )
    {
        return;
    }

    WaitForSingleObject( m_hInitializedEvent, 5000 );

}

void CWbemRefresher::Cleanup( void )
{
    // If we have a thread, tell it to go away
    if ( NULL != m_hThread )
    {
        // Signal the quit event and give the thread a 5 second grace period
        // to shutdown.  If it don't, don't worry, just close the handle and go away.

        SetEvent( m_hQuitEvent );
        WaitForSingleObject( m_hThread, 5000 );

        CloseHandle( m_hThread );
        m_hThread = NULL;
    }

    // Cleanup the primitives

    if ( NULL != m_hQuitEvent )
    {
        CloseHandle( m_hQuitEvent );
        m_hQuitEvent = NULL;
    }

    if ( NULL != m_hDoWorkEvent )
    {
        CloseHandle( m_hDoWorkEvent );
        m_hDoWorkEvent = NULL;
    }

    if ( NULL != m_hInitializedEvent )
    {
        CloseHandle( m_hInitializedEvent );
        m_hInitializedEvent = NULL;
    }

    if ( NULL != m_hWorkDoneEvent )
    {
        CloseHandle( m_hWorkDoneEvent );
        m_hWorkDoneEvent = NULL;
    }

    if ( NULL != m_hRefrMutex )
    {
        CloseHandle( m_hRefrMutex );
        m_hRefrMutex = NULL;
    }

}

DWORD CWbemRefresher::RealEntry( void )
{
    // Grab hold of all the things we may care about in case some evil timing
    // problem occurs, so we don't get left trying to hit on member variables that
    // don't exist anymore.

    HANDLE  hQuitEvent          =   m_hQuitEvent,
            hDoWorkEvent        =   m_hDoWorkEvent,
            hInitializedEvent   =   m_hInitializedEvent,
            hWorkDoneEvent      =   m_hWorkDoneEvent;

    DWORD   dwWait = 0;

    HANDLE  ahEvents[2];

    ahEvents[0] = hDoWorkEvent;
    ahEvents[1] = hQuitEvent;

    // Initialize this thread
    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    if (hr == S_FALSE) {
        // COM library is already initialized, we can continue;
        //
        hr = S_OK;
    }

    // Now get the refresher and config refresher pointers.

    IWbemRefresher*             pWbemRefresher = NULL;
    IWbemConfigureRefresher*    pWbemConfig = NULL;

    if ( SUCCEEDED( hr ) )
    {
        hr = CoCreateInstance (CLSID_WbemRefresher, 0, CLSCTX_SERVER,
                        IID_IWbemRefresher, (LPVOID *)&pWbemRefresher);

        if ( SUCCEEDED( hr ) )
        {
            pWbemRefresher->QueryInterface( IID_IWbemConfigureRefresher, (LPVOID *) &pWbemConfig );
        }

    }

    //  Obviously we can't go any further if we don't have our pointers correctly
    //  setup.
    m_fThreadOk = SUCCEEDED( hr );

    // Ready to go --- Signal the Initialized Event
    SetEvent( hInitializedEvent );

    if ( m_fThreadOk )
    {

        while ( ( dwWait = WaitForMultipleObjects( 2, ahEvents, FALSE,  INFINITE ) ) == WAIT_OBJECT_0 )
        {
            // Don't continue if quit is signalled
            if ( WaitForSingleObject( hQuitEvent, 0 ) == WAIT_OBJECT_0 )
            {
                break;
            }

            // This is where we'll do the real operation

            switch( m_eRefrOp )
            {
                case eRefrOpRefresh:
                {
                    m_hOperResult = pWbemRefresher->Refresh( m_lFlags );
                    break;
                }

                // For both of these ops, we will need to umarshal the
                // namespace
                case eRefrOpAddEnum:
                case eRefrOpAddByPath:
                {
                    IWbemServices*  pNamespace = NULL;

                    // Unmarshal the interface, then set security
                    m_hOperResult = CoGetInterfaceAndReleaseStream(
                        m_pNSStream, IID_IWbemServices,
                        (void**) &pNamespace );
                    m_pNSStream = NULL;

                    if ( SUCCEEDED( m_hOperResult ) )
                    {
                        m_hOperResult = SetWbemSecurity( pNamespace );

                        if ( SUCCEEDED( m_hOperResult ) )
                        {
                            if ( eRefrOpAddByPath == m_eRefrOp )
                            {
                                m_hOperResult = pWbemConfig->AddObjectByPath(
                                    pNamespace, m_wszPath, m_lFlags, NULL,
                                    m_ppRefreshable, m_plId );
                            }
                            else
                            {
                                m_hOperResult = pWbemConfig->AddEnum(
                                    pNamespace, m_wszClassName, m_lFlags, NULL,
                                    m_ppEnum, m_plId );
                            }
                        }

                        pNamespace->Release();
                    }

                    break;
                }

                case eRefrOpRemove:
                {
                    m_hOperResult = pWbemConfig->Remove( m_lId, m_lFlags );
                    break;
                }

                default:
                {
                    m_hOperResult = WBEM_E_FAILED;
                }
            }

            // Signal the event to let a waiting thread know we're done doing
            // what it asked us to do.
            SetEvent( hWorkDoneEvent );
        }

    }

    // This means we're not processing anymore (for whatever reason)
    m_fThreadOk = FALSE;

    // Cleanup our pointers
    if ( NULL != pWbemRefresher )
    {
        pWbemRefresher->Release();
    }

    if ( NULL != pWbemConfig )
    {
        pWbemConfig->Release();
    }

    CoUninitialize();

    return 0;
}

// CWbemRefresher class functions
SCODE CWbemRefresher::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
    *ppvObj = 0;

    if (IID_IUnknown==riid)
    {
        *ppvObj = (IUnknown*)this;
        AddRef();
        return NOERROR;
    }
    else if ( IID_IWbemRefresher == riid )
    {
        *ppvObj = (IWbemRefresher*) &m_xRefresher;
        AddRef();
        return NOERROR;
    }
    else if ( IID_IWbemConfigureRefresher == riid )
    {
        *ppvObj = (IWbemConfigureRefresher*) &m_xConfigRefresher;
        AddRef();
        return NOERROR;
    }

    return ResultFromScode(E_NOINTERFACE);
}

ULONG CWbemRefresher::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

ULONG CWbemRefresher::Release()
{
    long lRef = InterlockedDecrement(&m_lRefCount);

    if (0 != lRef)
        return lRef;

    delete this;
    return 0;
}

HRESULT CWbemRefresher::SignalRefresher( void )
{
    HRESULT hr = WBEM_S_NO_ERROR;

    if ( SetEvent( m_hDoWorkEvent ) )
    {
        if ( WaitForSingleObject( m_hWorkDoneEvent, INFINITE ) == WAIT_OBJECT_0 )
        {
            hr = m_hOperResult;
        }
        else
        {
            hr = WBEM_E_FAILED;
        }
    }
    else
    {
        hr = WBEM_E_FAILED;
    }

    ClearRefresherParams();

    return hr;
}

HRESULT CWbemRefresher::SetRefresherParams( IWbemServices* pNamespace, tRefrOps eOp,
            LPCWSTR pwszPath, LPCWSTR pwszClassName, long lFlags,
            IWbemClassObject** ppRefreshable, IWbemHiPerfEnum** ppEnum, long* plId,
            long lId )
{
    HRESULT hr = WBEM_S_NO_ERROR;

    if ( NULL != pNamespace )
    {
        // Marshal the namespace pointer into the stream member
        hr = CoMarshalInterThreadInterfaceInStream( IID_IWbemServices, pNamespace,
            &m_pNSStream );
    }
    else
    {
        m_pNSStream = NULL;
    }

    if ( SUCCEEDED( hr ) )
    {
        m_eRefrOp = eOp;
        m_wszPath = pwszPath;
        m_wszClassName = pwszClassName,
        m_lFlags = lFlags;
        m_ppRefreshable = ppRefreshable;
        m_ppEnum = ppEnum;
        m_plId = plId;
        m_lId = lId;
    }

    return hr;
}

void CWbemRefresher::ClearRefresherParams( void )
{
    m_pNSStream = NULL;
    m_eRefrOp = eRefrOpNone;
    m_wszPath = NULL;
    m_wszClassName = NULL,
    m_lFlags = 0L;
    m_ppRefreshable = NULL;
    m_ppEnum = NULL;
    m_plId = NULL;
    m_lId = 0L;
    m_hOperResult = WBEM_S_NO_ERROR;
}

// These are the real method implementations
STDMETHODIMP CWbemRefresher::AddObjectByPath(
    IWbemServices* pNamespace, LPCWSTR wszPath,
    long lFlags, IWbemContext* pContext,
    IWbemClassObject** ppRefreshable, long* plId)
{
    HRESULT hr = WBEM_E_FAILED;

    UNREFERENCED_PARAMETER (pContext);

    if ( WaitForSingleObject( m_hRefrMutex, WBEM_REFRESHER_TIMEOUT ) == WAIT_OBJECT_0 )
    {
        // Check that the thread is still running
        if ( m_fThreadOk )
        {
            // Setup the parameters and perform the operation
            hr = SetRefresherParams( pNamespace, eRefrOpAddByPath, wszPath, NULL,
                    lFlags, ppRefreshable, NULL, plId, 0L );

            if ( SUCCEEDED( hr ) )
            {
                // This is where we ask the thread to do the work
                hr = SignalRefresher();
            }
        }
        else
        {
            hr = WBEM_E_FAILED;
        }

        ReleaseMutex( m_hRefrMutex );
    }
    else
    {
        hr = WBEM_E_REFRESHER_BUSY;
    }

    return hr;
}

STDMETHODIMP CWbemRefresher::AddObjectByTemplate(
    IWbemServices* pNamespace,
    IWbemClassObject* pTemplate,
    long lFlags, IWbemContext* pContext,
    IWbemClassObject** ppRefreshable, long* plId)
{
    UNREFERENCED_PARAMETER (pNamespace);
    UNREFERENCED_PARAMETER (pTemplate);
    UNREFERENCED_PARAMETER (lFlags);
    UNREFERENCED_PARAMETER (pContext);
    UNREFERENCED_PARAMETER (ppRefreshable);
    UNREFERENCED_PARAMETER (plId);

    // We don't call this internally, so don't implement
    return WBEM_E_METHOD_NOT_IMPLEMENTED;
}

STDMETHODIMP CWbemRefresher::Remove(long lId, long lFlags)
{

    HRESULT hr = WBEM_E_FAILED;

    UNREFERENCED_PARAMETER (lId);
    UNREFERENCED_PARAMETER (lFlags);

    if ( WaitForSingleObject( m_hRefrMutex, WBEM_REFRESHER_TIMEOUT ) == WAIT_OBJECT_0 )
    {
        // Check that the thread is still running
        if ( m_fThreadOk )
        {
            // Setup the parameters and perform the operation
            hr = SetRefresherParams( NULL, eRefrOpRemove, NULL, NULL,
                    lFlags, NULL, NULL, NULL, lId );

            if ( SUCCEEDED( hr ) )
            {
                // This is where we ask the thread to do the work
                hr = SignalRefresher();
            }
        }
        else
        {
            hr = WBEM_E_FAILED;
        }

        ReleaseMutex( m_hRefrMutex );
    }
    else
    {
        hr = WBEM_E_REFRESHER_BUSY;
    }

    return hr;

}

STDMETHODIMP CWbemRefresher::AddRefresher(
                    IWbemRefresher* pRefresher, long lFlags, long* plId)
{
    UNREFERENCED_PARAMETER (lFlags);
    UNREFERENCED_PARAMETER (pRefresher);
    UNREFERENCED_PARAMETER (plId);

    // We don't call this internally, so don't implement
    return WBEM_E_METHOD_NOT_IMPLEMENTED;
}

HRESULT CWbemRefresher::AddEnum(
        IWbemServices* pNamespace, LPCWSTR wszClassName,
        long lFlags, IWbemContext* pContext, IWbemHiPerfEnum** ppEnum,
        long* plId)
{

    HRESULT hr = WBEM_E_FAILED;

    UNREFERENCED_PARAMETER (pContext);

    if ( WaitForSingleObject( m_hRefrMutex, WBEM_REFRESHER_TIMEOUT ) == WAIT_OBJECT_0 )
    {
        // Check that the thread is still running
        if ( m_fThreadOk )
        {
            // Setup the parameters and perform the operation
            hr = SetRefresherParams( pNamespace, eRefrOpAddEnum, NULL, wszClassName,
                    lFlags, NULL, ppEnum, plId, 0L );

            if ( SUCCEEDED( hr ) )
            {
                // This is where we ask the thread to do the work
                hr = SignalRefresher();
            }
        }
        else
        {
            hr = WBEM_E_FAILED;
        }

        ReleaseMutex( m_hRefrMutex );
    }
    else
    {
        hr = WBEM_E_REFRESHER_BUSY;
    }

    return hr;

}

STDMETHODIMP CWbemRefresher::Refresh( long lFlags )
{
    HRESULT hr = WBEM_E_FAILED;

    if ( WaitForSingleObject( m_hRefrMutex, WBEM_REFRESHER_TIMEOUT ) == WAIT_OBJECT_0 )
    {
        // Check that the thread is still running
        if ( m_fThreadOk )
        {
            // Setup the parameters and perform the operation
            hr = SetRefresherParams( NULL, eRefrOpRefresh, NULL, NULL,
                    lFlags, NULL, NULL, NULL, 0L );

            if ( SUCCEEDED( hr ) )
            {
                // This is where we ask the thread to do the work
                hr = SignalRefresher();
            }
        }
        else
        {
            hr = WBEM_E_FAILED;
        }

        ReleaseMutex( m_hRefrMutex );
    }
    else
    {
        hr = WBEM_E_REFRESHER_BUSY;
    }

    return hr;
}

// XRefresher
SCODE CWbemRefresher::XRefresher::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
    return m_pOuter->QueryInterface( riid, ppvObj );
}

ULONG CWbemRefresher::XRefresher::AddRef()
{
    return m_pOuter->AddRef();
}

ULONG CWbemRefresher::XRefresher::Release()
{
    return m_pOuter->Release();
}

STDMETHODIMP CWbemRefresher::XRefresher::Refresh( long lFlags )
{
    // Pass through
    return m_pOuter->Refresh( lFlags );
}

// XConfigRefresher
SCODE CWbemRefresher::XConfigRefresher::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
    return m_pOuter->QueryInterface( riid, ppvObj );
}

ULONG CWbemRefresher::XConfigRefresher::AddRef()
{
    return m_pOuter->AddRef();
}

ULONG CWbemRefresher::XConfigRefresher::Release()
{
    return m_pOuter->Release();
}

STDMETHODIMP CWbemRefresher::XConfigRefresher::AddObjectByPath(
    IWbemServices* pNamespace, LPCWSTR wszPath,
    long lFlags, IWbemContext* pContext,
    IWbemClassObject** ppRefreshable, long* plId)
{
    // Pass through
    return m_pOuter->AddObjectByPath( pNamespace, wszPath, lFlags, pContext,
            ppRefreshable, plId );
}

STDMETHODIMP CWbemRefresher::XConfigRefresher::AddObjectByTemplate(
    IWbemServices* pNamespace,
    IWbemClassObject* pTemplate,
    long lFlags, IWbemContext* pContext,
    IWbemClassObject** ppRefreshable, long* plId)
{
    // Pass through
    return m_pOuter->AddObjectByTemplate( pNamespace, pTemplate, lFlags, pContext,
            ppRefreshable, plId );
}

STDMETHODIMP CWbemRefresher::XConfigRefresher::Remove(long lId, long lFlags)
{
    return m_pOuter->Remove( lId, lFlags );
}

STDMETHODIMP CWbemRefresher::XConfigRefresher::AddRefresher(
                    IWbemRefresher* pRefresher, long lFlags, long* plId)
{
    return m_pOuter->AddRefresher( pRefresher, lFlags, plId );
}

HRESULT CWbemRefresher::XConfigRefresher::AddEnum(
        IWbemServices* pNamespace, LPCWSTR wszClassName,
        long lFlags, IWbemContext* pContext, IWbemHiPerfEnum** ppEnum,
        long* plId)
{
    return m_pOuter->AddEnum( pNamespace, wszClassName, lFlags, pContext,
            ppEnum, plId );
}

/*
**  End CWbemRefresher Implementation!
*/

// HELPER Function to establish the CWbemRefresher Interface pass-thru
HRESULT CoCreateRefresher( IWbemRefresher** ppRefresher )
{
    HRESULT hr = WBEM_S_NO_ERROR;

    // Allocate the pass-thru object then, if successful, get
    // the interface pointer out of it
    CWbemRefresher* pWbemRefresher = new CWbemRefresher;

    if ( NULL != pWbemRefresher )
    {
        hr = pWbemRefresher->QueryInterface( IID_IWbemRefresher, (LPVOID*) ppRefresher );
    }
    else
    {
        hr = WBEM_E_OUT_OF_MEMORY;
    }

    return hr;
}

PPDHI_WBEM_SERVER_DEF pFirstWbemServer = NULL;
//BOOL    bWbemInitialized = FALSE;

BOOL    bSecurityInitialized = FALSE;
IGlobalInterfaceTable * gp_GIT = NULL;

BOOL PdhiCoInitialize( void )
{
    HRESULT sc = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    if ( !bSecurityInitialized )
    {
        // In case it hasn't been
        HRESULT hr = CoInitializeSecurity(
            NULL,   //Points to security descriptor
            -1L,     //Count of entries in asAuthSvc -1 means use default
            NULL,   //Array of names to register
            NULL,   //Reserved for future use
            RPC_C_AUTHN_LEVEL_PKT,  //The default authentication level
                                // for proxies
            RPC_C_IMP_LEVEL_IMPERSONATE,    //The default impersonation level
                                // for proxies
            NULL,   //Authentication information for
                    // each authentication service
            EOAC_NONE,   //Additional client and/or
                            // server-side capabilities
            NULL    //Reserved for future use
            );

        bSecurityInitialized = (hr == S_OK || hr == RPC_E_TOO_LATE);
    }

    if (gp_GIT == NULL) {
        HRESULT hr1 = CoCreateInstance(CLSID_StdGlobalInterfaceTable, 
                                       NULL,
                                       CLSCTX_INPROC_SERVER, 
                                       IID_IGlobalInterfaceTable,
                                       (void **) & gp_GIT); 
        if (hr1 != ERROR_SUCCESS) {
            gp_GIT = NULL;
        }
    }

    // We will only return that this succeeded if the call to CoInitializeEx
    // returned S_FALSE.  If it didn't, it either errored or returned S_OK.
    // If S_OK, we will assume that the client isn't doing any COM stuff
    // natively.  If S_FALSE, the client already CoInitialized this thread
    // so we just bumped up the ref count and should cleanup on the way
    // out

    return (S_FALSE == sc);
}

void PdhiCoUninitialize( void )
{
    CoUninitialize();
}

PDH_FUNCTION PdhiCloseWbemServer (PPDHI_WBEM_SERVER_DEF pWbemServer);

PDH_FUNCTION
PdhiDisconnectWbemServer (
    PPDHI_WBEM_SERVER_DEF pWbemServer
)
{
    PDH_STATUS  pdhReturn = ERROR_SUCCESS;
    if (pWbemServer != NULL) {
        pWbemServer->lRefCount--;
        if (pWbemServer->lRefCount < 0) {
            pWbemServer->lRefCount = 0;
        }
    }

    return pdhReturn;
}

PDH_FUNCTION
PdhiFreeWbemQuery (
    PPDHI_QUERY     pThisQuery
)
{
    HRESULT hRes;

    if (!bProcessIsDetaching) {
        if ((pThisQuery->pRefresherCfg) != NULL) {
            hRes = pThisQuery->pRefresherCfg->Release ();
            pThisQuery->pRefresherCfg = NULL;
        }

        if ((pThisQuery->pRefresher) != NULL) {
            hRes = pThisQuery->pRefresher->Release ();
            pThisQuery->pRefresher = NULL;
        }
    }
    return ERROR_SUCCESS;
}

PDH_FUNCTION
PdhiCloseWbemCounter (
    PPDHI_COUNTER   pThisCounter
)
{
    HRESULT hRes;
    BOOLEAN bRemoveRefresher = TRUE;

    if (!bProcessIsDetaching) {
        if (pThisCounter->pOwner->pRefresherCfg != NULL) {
            PPDHI_QUERY   pQuery   = pThisCounter->pOwner;
            PPDHI_COUNTER pCounter = pQuery->pCounterListHead;

            do {
                if (pCounter == NULL) {
                    bRemoveRefresher = FALSE;
                }
                else if (pCounter != pThisCounter && pCounter->lWbemRefreshId
                                == pThisCounter->lWbemRefreshId) {
                    bRemoveRefresher = FALSE;
                }
                else {
                    pCounter = pCounter->next.flink;
                }
            }
            while (bRemoveRefresher && pCounter != NULL
                                    && pCounter != pQuery->pCounterListHead);

            if (bRemoveRefresher) {
                hRes = pThisCounter->pOwner->pRefresherCfg->Remove(
                                pThisCounter->lWbemRefreshId, 0L);
            }
            // assert (hRes == S_OK); the function returns a BOOL even though it's defined as an HRESULT
//            pThisCounter->pOwner->pRefresherCfg->Release();
//            pThisCounter->pOwner->pRefresherCfg = NULL;
        }

        if (pThisCounter->pWbemAccess != NULL) {
            pThisCounter->pWbemAccess->Release();
            pThisCounter->pWbemAccess = NULL;
        }

        if (pThisCounter->pWbemObject != NULL) {
            pThisCounter->pWbemObject->Release();
            pThisCounter->pWbemObject = NULL;
        }
    }

    return ERROR_SUCCESS;
}

PDH_FUNCTION
PdhiBreakWbemMachineName (
    LPCWSTR     szMachineAndNamespace,
    LPWSTR      szMachine,
    LPWSTR      szNamespace
)
/*
    assumes szMachine and szPath are large enough to hold the result
*/
{
    LPWSTR  szSrc = NULL;
    LPWSTR  szDest = NULL;

    assert (szMachine != NULL);
    assert (szNamespace != NULL);

    szSrc = (LPWSTR)szMachineAndNamespace;

    if (szSrc == NULL) {
        // then use local machine and default namespace
        lstrcpyW (szMachine, szStaticLocalMachineName); // local machine
        lstrcpyW (szNamespace, cszWbemDefaultPerfRoot);
        return ERROR_SUCCESS;
    } else {
        // break into components
        if (*szSrc  != NULL) {
            // there's a string, see if it's a machine or a namespace
            if ((szSrc[0] == L'\\') && (szSrc[1] == L'\\')) {
                szDest = szMachine;
                // then there's a machine name
                *szDest++ = *szSrc++;
                *szDest++ = *szSrc++;
                while ((*szSrc != 0) && (*szSrc != L'\\')){
                    *szDest++ = *szSrc++;
                }
                *szDest = 0;
            } else {
                // no machine so use default
                // it must be just a namespace
            }
        } else {
            // no machine so use default
        }

        if (szDest == NULL) {
            // nothing found yet, so insert local machine as default
            szDest = szMachine;
            lstrcpyW (szDest, szStaticLocalMachineName);
        }

        szDest = szNamespace;

        if (*szSrc != 0) {
            // if there's a namespace then copy it
            szSrc++;    // move past backslash
            while (*szSrc != 0) {
                *szDest++ = *szSrc++;
            }
            *szDest = 0;
        } else {
            // else return the default;
            lstrcpyW (szDest, cszWbemDefaultPerfRoot);
        }
        return ERROR_SUCCESS;
    }
}

PDH_FUNCTION
PdhiMakeWbemInstancePath (
    IN      PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElements,
    IN      LPWSTR                      szFullPathBuffer,
    IN      BOOL                        bMakeRelativePath
)
{
    WCHAR   szMachine[MAX_PATH];
    WCHAR   szNamespace[MAX_PATH];
    WCHAR   szWbemInstance[MAX_PATH];

    LPWSTR  szSrc, szDest;
    //  the function assumes that the path buffer is sufficiently large
    //  to hold the result
    //
    //
    // the wbem class instance path consists of one of the following formats:
    // for perf objects with one and only one instance (singleton classes in
    // WBEM parlance) the format is
    //
    //      <objectname>=@
    //
    // for object with instances, the format is
    //
    //      <objectname>.Name="<instancename>"
    //
    if (!bMakeRelativePath) {
        PdhiBreakWbemMachineName (
            pCounterPathElements->szMachineName,
            szMachine,
            szNamespace);
        lstrcpyW (szFullPathBuffer, szMachine);
        lstrcatW (szFullPathBuffer, cszBackSlash);
        lstrcatW (szFullPathBuffer, szNamespace);
        lstrcatW (szFullPathBuffer, cszColon);
    } else {
        *szFullPathBuffer = 0;
    }

    if (pCounterPathElements->szInstanceName == NULL) {
        // then apply the singleton logic
        lstrcatW (szFullPathBuffer, pCounterPathElements->szObjectName);
        lstrcatW (szFullPathBuffer, cszSingletonInstance);
    } else {
        // wbem will interpret the backslash character as an
        // escape char (as "C" does) so we'll have to double each
        // backslash in the string to make it come out OK
        szDest = &szWbemInstance[0];
        if (pCounterPathElements->szParentInstance != NULL) {
            szSrc = pCounterPathElements->szParentInstance;
            while (*szSrc != 0) {
                *szDest = *szSrc;
                if (*szSrc == BACKSLASH_L) {
                    *++szDest = BACKSLASH_L;
                }
                szDest++;
                szSrc++;
                assert (szDest < &szWbemInstance[MAX_PATH]);
            }
            *szDest++ = '/'; // parent/child delimiter
        }
        szSrc = pCounterPathElements->szInstanceName;
        while (*szSrc != 0) {
            *szDest = *szSrc;
            if (*szSrc == BACKSLASH_L) {
                *++szDest = BACKSLASH_L;
            }
            szDest++;
            szSrc++;
            assert (szDest < &szWbemInstance[MAX_PATH]);
        }
        *szDest = 0;
        // apply the instance name format
        lstrcatW (szFullPathBuffer, pCounterPathElements->szObjectName);
        lstrcatW (szFullPathBuffer, cszNameParam);
        lstrcatW (szFullPathBuffer, szWbemInstance);
        lstrcatW (szFullPathBuffer, cszDoubleQuote);
    }
    return ERROR_SUCCESS;
}

PDH_FUNCTION
PdhiWbemGetCounterPropertyName (
    IWbemClassObject        *pThisClass,
    LPCWSTR                 szCounterDisplayName,
    LPWSTR                  szPropertyName,
    DWORD                   dwPropertyNameSize
)
{
    HRESULT         hResult;
    PDH_STATUS      pdhStatus = PDH_CSTATUS_NO_COUNTER;
    SAFEARRAY       *psaNames = NULL;
    long            lLower; 
    long            lUpper = 0;
    long            lCount;
    BSTR            bsPropName = NULL;
    BSTR            bsCountertype = NULL;
    BSTR            bsDisplayname = NULL;
    VARIANT         vName, vCountertype;
    IWbemQualifierSet       *pQualSet = NULL;

    VariantInit (&vName);
    VariantInit (&vCountertype);

    // get the properties of this class as a Safe Array
    hResult = pThisClass->GetNames (NULL,
        WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
    if (hResult == WBEM_NO_ERROR) {
        hResult = SafeArrayGetLBound (psaNames, 1, &lLower);
        if (hResult == S_OK) {
            hResult = SafeArrayGetUBound (psaNames, 1, &lUpper);
        }
        if (hResult == S_OK) {
            bsCountertype = SysAllocString (cszCountertype);
            bsDisplayname = SysAllocString (cszDisplayname);
            if (bsCountertype && bsDisplayname) {
                for (lCount = lLower; lCount <= lUpper; lCount++) {
                    hResult = SafeArrayGetElement (psaNames, &lCount, &bsPropName);
                    if (hResult == S_OK) {
                        // this is the desired counter so
                        // get the qualifier set for this property
                        hResult = pThisClass->GetPropertyQualifierSet (
                            bsPropName, &pQualSet);
                        if (hResult == WBEM_NO_ERROR) {
                            LONG    lCounterType;
                            // make sure this is a perf counter property
                            hResult = pQualSet->Get (bsCountertype, 0, &vCountertype, NULL);
                            if (hResult == WBEM_NO_ERROR) {
                                lCounterType = V_I4(&vCountertype);
                                // then see if this is a displayable counter
                                if (!(lCounterType & PERF_DISPLAY_NOSHOW) ||
                                    (lCounterType == PERF_AVERAGE_BULK)) {
                                    // by testing for the counter type
                                    // get the display name for this property
                                    hResult = pQualSet->Get (bsDisplayname, 0, &vName, NULL);
                                    if (hResult == WBEM_NO_ERROR) {
                                        // display name found compare it
                                        if (lstrcmpiW(szCounterDisplayName, V_BSTR(&vName)) == 0) {
                                            // then this is the correct property so return
                                            if ((DWORD)lstrlenW(bsPropName) < dwPropertyNameSize) {
                                                lstrcpyW (szPropertyName, (LPWSTR)bsPropName);
                                                pdhStatus = ERROR_SUCCESS;
                                                pQualSet->Release();
                                                pQualSet = NULL;
                                                break;
                                            } else {
                                                pdhStatus = PDH_MORE_DATA;
                                            }
                                        } else {
                                            //not this property so continue
                                        }
                                    }
                                } else {
                                    // this is a "don't show" counter so skip it
                                }
                            } else {
                                // unable to get the counter type so it's probably
                                // not a perf counter property, skip it and continue
                            }
                            VariantClear (&vName);
                            VariantClear (&vCountertype);
                            pQualSet->Release();
                            pQualSet = NULL;
                        } else {
                            // unable to read qualifiers so skip
                            continue;
                        }
                    } else {
                        // unable to read element in SafeArray
                        pdhStatus = PDH_WBEM_ERROR;
                        SetLastError(hResult);
                    }
                } // end for each element in SafeArray
            } else {
                pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            }
            PdhiSysFreeString (&bsCountertype);
            PdhiSysFreeString (&bsDisplayname);
        } else {
            // unable to get array boundries
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }

    } else {
        // unable to get property strings
        pdhStatus = PDH_WBEM_ERROR;
        SetLastError (hResult);
    }

    VariantClear (&vName);
    VariantClear (&vCountertype);

    if (psaNames != NULL) {
        // Clear the SafeArray if it exists
        SafeArrayDestroy( psaNames );
    }

    // make sure it was released
    assert (pQualSet == NULL);

    return pdhStatus;
}

PDH_FUNCTION
PdhiWbemGetCounterDisplayName (
    IWbemClassObject        *pThisClass,
    LPCWSTR                 szCounterName,
    LPWSTR                  szDisplayName,
    DWORD                   dwDisplayNameSize
)
{
    HRESULT         hResult;
    PDH_STATUS      pdhStatus = PDH_CSTATUS_NO_COUNTER;
    SAFEARRAY       *psaNames = NULL;
    long            lLower; 
    long            lUpper = 0;
    long            lCount;
    BSTR            bsPropName = NULL;
    BSTR            bsCountertype = NULL;
    BSTR            bsDisplayname = NULL;
    VARIANT         vName, vCountertype;
    IWbemQualifierSet       *pQualSet = NULL;

    VariantInit (&vName);
    VariantInit (&vCountertype);

    // get the properties of this class as a Safe Array
    hResult = pThisClass->GetNames (NULL,
        WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
    if (hResult == WBEM_NO_ERROR) {
        hResult = SafeArrayGetLBound (psaNames, 1, &lLower);
        if (hResult == S_OK) {
            hResult = SafeArrayGetUBound (psaNames, 1, &lUpper);
        }
        if (hResult == S_OK) {
            bsCountertype = SysAllocString (cszCountertype);
            bsDisplayname = SysAllocString (cszDisplayname);
            if (bsCountertype && bsDisplayname) {
                for (lCount = lLower; lCount <= lUpper; lCount++) {
                    hResult = SafeArrayGetElement (psaNames, &lCount, &bsPropName);
                    if (hResult == S_OK) {
                        if (lstrcmpiW ((LPWSTR)bsPropName, szCounterName) == 0) {
                            // this is the desired counter so
                            // get the qualifier set for this property
                            hResult = pThisClass->GetPropertyQualifierSet (
                                bsPropName, &pQualSet);
                            if (hResult == WBEM_NO_ERROR) {
                                LONG    lCounterType;
                                // make sure this is a perf counter property
                                hResult = pQualSet->Get (bsCountertype, 0, &vCountertype, NULL);
                                if (hResult == WBEM_NO_ERROR) {
                                    lCounterType = V_I4(&vCountertype);
                                    // then see if this is a displayable counter
                                    if (!(lCounterType & PERF_DISPLAY_NOSHOW) ||
                                        (lCounterType == PERF_AVERAGE_BULK)) {
                                        // by testing for the counter type
                                        // get the display name for this property
                                        hResult = pQualSet->Get (bsDisplayname, 0, &vName, NULL);
                                        if (hResult == WBEM_NO_ERROR) {
                                            // display name found so copy and break
                                            if ((DWORD)lstrlenW(V_BSTR(&vName)) < dwDisplayNameSize) {
                                                lstrcpyW (szDisplayName, V_BSTR(&vName));
                                                pdhStatus = ERROR_SUCCESS;
                                                pQualSet->Release();
                                                pQualSet = NULL;
                                                break;
                                            } else {
                                                pdhStatus = PDH_MORE_DATA;
                                            }
                                        }
                                    } else {
                                        // this is a "don't show" counter so skip it
                                    }
                                } else {
                                    // unable to get the counter type so it's probably
                                    // not a perf counter property, skip it and continue
                                }
                                VariantClear (&vName);
                                VariantClear (&vCountertype);
                                pQualSet->Release();
                                pQualSet = NULL;
                            } else {
                                // unable to read qualifiers so skip
                                continue;
                            }
                        } else {
                            // aren't interested in this property, so
                            continue;
                        }
                    } else {
                        // unable to read element in SafeArray
                        pdhStatus = PDH_WBEM_ERROR;
                        SetLastError(hResult);
                    }
                } // end for each element in SafeArray
            } else {
                pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            }
            PdhiSysFreeString (&bsCountertype);
            PdhiSysFreeString (&bsDisplayname);
        } else {
            // unable to get array boundries
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }

    } else {
        // unable to get property strings
        pdhStatus = PDH_WBEM_ERROR;
        SetLastError (hResult);
    }

    VariantClear (&vName);
    VariantClear (&vCountertype);

    // Clear the SafeArray if it exists
    if ( NULL != psaNames )
    {
        SafeArrayDestroy( psaNames );
    }
    // make sure it was released
    assert (pQualSet == NULL);

    return pdhStatus;
}

PDH_FUNCTION
PdhiWbemGetClassObjectByName (
    PPDHI_WBEM_SERVER_DEF   pThisServer,
    LPCWSTR                 szClassName,
    IWbemClassObject        **pReturnClass
)
{
    PDH_STATUS  pdhStatus = ERROR_SUCCESS;

    HRESULT hResult;
    BSTR    bsClassName;

    IWbemClassObject        *pThisClass = NULL;

    bsClassName = SysAllocString (szClassName);

    if (bsClassName) {
        hResult = pThisServer->pSvc->GetObject (
            bsClassName, // class name
            WBEM_FLAG_USE_AMENDED_QUALIFIERS, NULL,
            &pThisClass,
            NULL);
        PdhiSysFreeString (&bsClassName);

        if (hResult != WBEM_NO_ERROR) {
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        } else {
            *pReturnClass = pThisClass;
        }
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    return (pdhStatus);
}

PDH_FUNCTION
PdhiWbemGetClassDisplayName (
    PPDHI_WBEM_SERVER_DEF   pThisServer,
    LPCWSTR                 szClassName,
    LPWSTR                  szClassDisplayName,
    DWORD                   dwClassDisplayNameSize,
    IWbemClassObject        **pReturnClass
)
{
    PDH_STATUS  pdhStatus = ERROR_SUCCESS;

    HRESULT hResult;
    BSTR    bsClassName;
    BSTR    bsClass;
    BSTR    bsDisplayName;
    VARIANT vName;
    LPWSTR  szDisplayName;

    IWbemClassObject        *pThisClass = NULL;
    IWbemQualifierSet       *pQualSet = NULL;

    VariantInit (&vName);

    bsClassName = SysAllocString (szClassName);

    if (bsClassName) {
        hResult = pThisServer->pSvc->GetObject (
            bsClassName, // class name
            WBEM_FLAG_USE_AMENDED_QUALIFIERS, NULL,
            &pThisClass,
            NULL);
        if (hResult != WBEM_NO_ERROR) {
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }
        PdhiSysFreeString (&bsClassName);
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // get the display name property of this class
        pThisClass->GetQualifierSet (&pQualSet);
        if (pQualSet != NULL) {
            bsDisplayName = SysAllocString (cszDisplayname);
            if (bsDisplayName) {
                hResult = pQualSet->Get (bsDisplayName, 0, &vName, 0);

                if (hResult == WBEM_E_NOT_FOUND) {
                    // then this has not display name so
                    // pull the class name
                    bsClass = SysAllocString (cszClass);
                    if (bsClass) {
                        hResult = pThisClass->Get (bsClass, 0, &vName, 0, 0);
                        PdhiSysFreeString (&bsClass);
                    } else {
                        hResult = WBEM_E_OUT_OF_MEMORY;
                    }
                } else {
                    hResult = WBEM_E_OUT_OF_MEMORY;
                }
                pQualSet->Release();
            } else {
                hResult = WBEM_E_OUT_OF_MEMORY;
            }
        } else {
            hResult = WBEM_E_NOT_FOUND;
        }

        if (hResult == WBEM_E_NOT_FOUND) {
            //unable to look up a display name so nothing to return
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        } else if (hResult == WBEM_E_OUT_OF_MEMORY) {
            pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            SetLastError(hResult);
        } else if (hResult == S_OK) {
            // copy string to caller's buffers
            szDisplayName = V_BSTR(&vName);
            if ((DWORD)lstrlenW(szDisplayName) < dwClassDisplayNameSize) {
                lstrcpyW (szClassDisplayName, szDisplayName);
                pdhStatus = ERROR_SUCCESS;
            }
            if (pReturnClass != NULL) {
                // return the class pointer, the caller will close it
                *pReturnClass = pThisClass;
            } else {
                // close it
                pThisClass->Release();
            }
        }
    }

    VariantClear (&vName);

    return pdhStatus;
}
BOOL
PdhiIsSingletonClass (
    IWbemClassObject        *pThisClass
)
{
    HRESULT                 hResult;
    BOOL                    bReturnValue = FALSE;   //
    BSTR                    bsSingleton = NULL;
    VARIANT                 vValue;
    IWbemQualifierSet       *pQualSet = NULL;

    bsSingleton = SysAllocString (cszSingleton);

    if (bsSingleton) {
        VariantInit (&vValue);
        // get the display name of this class
        pThisClass->GetQualifierSet (&pQualSet);
        if (pQualSet != NULL) {
            hResult = pQualSet->Get (bsSingleton, 0, &vValue, 0);
            pQualSet->Release();
        } else {
            hResult = WBEM_E_NOT_FOUND;
        }

        if (hResult == ERROR_SUCCESS) {
            bReturnValue = TRUE;
        }

        VariantClear (&vValue);
        PdhiSysFreeString (&bsSingleton);
    } else {
        bReturnValue = FALSE;
    }

    return bReturnValue;
}

#pragma warning ( disable : 4127 )
PDH_FUNCTION
PdhiEnumWbemServerObjects(
    IN  PPDHI_WBEM_SERVER_DEF   pThisServer,
    IN  LPVOID                  mszObjectList,
    IN  LPDWORD                 pcchBufferSize,
    IN  DWORD                   dwDetailLevel,
    IN  BOOL                    bRefresh,
    IN  BOOL                    bUnicode
);

PDH_FUNCTION
PdhiWbemGetObjectClassName (
    PPDHI_WBEM_SERVER_DEF   pThisServer,
    LPCWSTR                 szObjectName,
    LPWSTR                  szObjectClassName,
    DWORD                   dwObjectClassNameSize,
    IWbemClassObject        **pReturnClass
)
{
    PDH_STATUS    pdhStatus = ERROR_SUCCESS;
    HRESULT       hResult;
    LONG          lResult;

    assert(pThisServer != NULL);
    assert(szObjectName != NULL);
    assert(szObjectClassName != NULL);
    assert(dwObjectClassNameSize > 0);

    if (pThisServer->pObjList == NULL) {
        DWORD dwSize = 0;
        pdhStatus = PdhiEnumWbemServerObjects(
                        pThisServer,
                        NULL,
                        & dwSize,
                        PERF_DETAIL_WIZARD | PERF_DETAIL_COSTLY,
                        TRUE,
                        TRUE);
        if (pThisServer->pObjList != NULL) {
            pdhStatus = ERROR_SUCCESS;
        }
    }

    if (pThisServer->pObjList != NULL) {
        PPDHI_WBEM_OBJECT_DEF pObject = pThisServer->pObjList;

        pdhStatus = PDH_CSTATUS_NO_OBJECT;
        while (pObject != NULL) {
            lResult = lstrcmpiW(pObject->szDisplay, szObjectName);
            if (lResult == 0) {
                if (  ((DWORD) lstrlenW(pObject->szObject))
                    < dwObjectClassNameSize) {
                    pdhStatus = ERROR_SUCCESS;
                    lstrcpyW(szObjectClassName, pObject->szObject);
                }
                else {
                    pdhStatus = PDH_MORE_DATA;
                }

                if (pObject->pClass == NULL) {
                    BSTR bsClassName = SysAllocString(pObject->szObject);
                    if (bsClassName) {
                        hResult = pThisServer->pSvc->GetObject(
                                bsClassName, WBEM_FLAG_USE_AMENDED_QUALIFIERS, NULL, & pObject->pClass, NULL);
                        if (hResult != WBEM_NO_ERROR) {
                            SetLastError(hResult);
                            pdhStatus = PDH_WBEM_ERROR;
                        }
                        else if (pReturnClass != NULL) {
                            * pReturnClass = pObject->pClass;
                        }
                    }
                    else {
                        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                    }
                }
                else if (pReturnClass != NULL) {
                    * pReturnClass = pObject->pClass;
                }
                break;
            }
            pObject = pObject->pNext;
        }
    }

    return pdhStatus;
}
#pragma warning ( default : 4127 )

PDH_FUNCTION
PdhiAddWbemServer (
    LPCWSTR  szMachineName,
    PPDHI_WBEM_SERVER_DEF *pWbemServer
)
{
    IWbemLocator    *pWbemLocator = 0;
    IWbemServices   *pWbemServices = 0;
    PDH_STATUS      pdhStatus = ERROR_SUCCESS;
    HRESULT         hResult;
    DWORD           dwResult;
    DWORD           dwStrLen = 0;
    PPDHI_WBEM_SERVER_DEF pNewServer = NULL;
    WCHAR           szLocalMachineName[MAX_PATH];
    WCHAR           szLocalServerPath[MAX_PATH];
    WCHAR           szLocalNameSpaceString[MAX_PATH];
    WCHAR           szLocale[32];

    // szMachineName can be null,
    // that means use the local machine and default namespace
    assert (pWbemServer != NULL);

    // connect to locator
    dwResult = CoCreateInstance (CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
        IID_IWbemLocator, (LPVOID *)&pWbemLocator);
    if (dwResult != S_OK) {
        SetLastError (dwResult);
        pdhStatus = PDH_CANNOT_CONNECT_MACHINE;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        PdhiBreakWbemMachineName (
            szMachineName,
            szLocalMachineName,
            szLocalNameSpaceString);
        lstrcpyW (szLocalServerPath, szLocalMachineName);
        lstrcatW (szLocalServerPath, szLocalNameSpaceString);

        // Create the locale
        swprintf( szLocale, L"MS_%hX", GetUserDefaultUILanguage());

        // try to connect to the service
        hResult = pWbemLocator->ConnectServer (
            szLocalServerPath,
            NULL, NULL, szLocale,
            0L,
            0,0,
            &pWbemServices);
        if (hResult) {
            SetLastError (hResult);
            pdhStatus =  PDH_CANNOT_CONNECT_WMI_SERVER;
        } else {
            dwStrLen = lstrlenW (szLocalMachineName ) + 1;

        }
        // free the locator
        pWbemLocator->Release();
    }

    // If we succeeded, we need to set Interface Security on the proxy and its
    // IUnknown in order for Impersonation to correctly work.

    if ( pdhStatus == ERROR_SUCCESS )
    {
        pdhStatus = SetWbemSecurity( pWbemServices );
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // everything went ok so save this connection
        if (*pWbemServer == NULL) {
            // then this is a new connection
            pNewServer = (PPDHI_WBEM_SERVER_DEF)G_ALLOC (sizeof (PDHI_WBEM_SERVER_DEF) + (dwStrLen * sizeof (WCHAR)));
            if (pNewServer == NULL) {
                pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            } else {
                // insert this at the head of the list
                pNewServer->pNext = pFirstWbemServer;
                pFirstWbemServer = pNewServer;
                pNewServer->szMachine = (LPWSTR)&pNewServer[1];
                lstrcpyW (pNewServer->szMachine, szLocalMachineName);
                pNewServer->lRefCount = 0; // it'll be incremented in the connect function
                *pWbemServer = pNewServer;
            }
        } else {
            // we are reconnecting and reusing an old memory block
            // so just update the pointer
            pNewServer = *pWbemServer;
        }
        // if reconnecting or connecting for the first time, this should be NULL
        assert (pNewServer->pSvc == NULL);

        if (pdhStatus == ERROR_SUCCESS) {
            // update fields
            // load the name fields
            pNewServer->pSvc     = pWbemServices;
            pNewServer->pObjList = NULL;
            pNewServer->dwCache  = 0;
            if (gp_GIT != NULL) {
                HRESULT hrTmp = gp_GIT->RegisterInterfaceInGlobal(
                                                pWbemServices,
                                                IID_IWbemServices,
                                                & (pNewServer->dwCache));
                DebugPrint((3,"RegisterInterfaceInGlobal(0x%08X,0x%08X,%d)\n",
                            hrTmp, pNewServer->pSvc, pNewServer->dwCache));
                if (! SUCCEEDED(hrTmp)) {
                    pWbemServices->Release();
                    pNewServer->pSvc    = NULL;
                    pNewServer->dwCache = 0;
                    pdhStatus           = PDH_WBEM_ERROR;
                }
            }
            else {
                pWbemServices->Release();
                pNewServer->pSvc    = NULL;
                pNewServer->dwCache = 0;
                pdhStatus           = PDH_WBEM_ERROR;
            }
        } else {
            // something failed so return a NULL for the server pointer
            *pWbemServer = NULL;
        }
    } else {
        // unable to connect so return NULL
        *pWbemServer = NULL;
    }

    // if there was an eror, then free the new sever memory
    if ((* pWbemServer) == NULL) G_FREE(pNewServer);

    return pdhStatus;
}

PDH_FUNCTION
PdhiCloseWbemServer (
    PPDHI_WBEM_SERVER_DEF pWbemServer
)
{
    assert (pWbemServer != NULL);

    if (!bProcessIsDetaching) {
        if (pWbemServer != NULL) {
            if (pWbemServer->pObjList != NULL) {
                PPDHI_WBEM_OBJECT_DEF pObject = pWbemServer->pObjList;
                PPDHI_WBEM_OBJECT_DEF pNext;

                pWbemServer->pObjList = NULL;
                while (pObject != NULL) {
                    pNext = pObject->pNext;
                    if (pObject->pClass != NULL) pObject->pClass->Release();
                    G_FREE(pObject);
                    pObject = pNext;
                }
            }
            if (pWbemServer->pSvc != NULL) {
                // this is about all that's currently required
                pWbemServer->pSvc->Release();
                pWbemServer->pSvc = NULL;
            } else {
                // no server is connected
            }
        } else {
            // no structure exists
        }
    }

    return ERROR_SUCCESS;
}

PDH_FUNCTION
PdhiConnectWbemServer (
    LPCWSTR  szMachineName,
    PPDHI_WBEM_SERVER_DEF *pWbemServer
)
{
    PDH_STATUS  pdhStatus = PDH_CANNOT_CONNECT_MACHINE;
    PPDHI_WBEM_SERVER_DEF pThisServer = NULL;

    LPWSTR  szWideMachineName = NULL;
    LPWSTR  szWideNamespace = NULL;
    LPWSTR  szMachineNameArg = NULL;

    // get the local machine name & default name space if the caller
    // has passed in a NULL machine name

    if (szMachineName == NULL) {
        szWideMachineName = (LPWSTR) G_ALLOC (2048 + 1024); // this should be long enough
        if (szWideMachineName == NULL) {
            pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
        } else {
            szWideNamespace = (LPWSTR)((LPBYTE)szWideMachineName + 2048);
        }

        if (pdhStatus != PDH_MEMORY_ALLOCATION_FAILURE) {
            pdhStatus = PdhiBreakWbemMachineName (
                NULL,
                szWideMachineName,
                szWideNamespace);
//            lstrcatW (szWideMachineName, cszBackSlash);
//            lstrcatW (szWideMachineName, szWideNamespace);
            szMachineNameArg = szWideMachineName;
        }
    } else {
        szMachineNameArg = (LPWSTR)szMachineName;
        pdhStatus = ERROR_SUCCESS;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // walk down list of connected servers and find the requested one
        assert (pWbemServer != NULL);

        for (pThisServer = pFirstWbemServer;
             pThisServer != NULL;
             pThisServer = pThisServer->pNext) {
            // machine name includes the namespace
            if (lstrcmpiW(pThisServer->szMachine, szMachineNameArg) == 0) {
                pdhStatus = ERROR_SUCCESS;
                break;
            }
        }

        if (pThisServer == NULL) {
             // then add it to the list and return it
             pdhStatus = PdhiAddWbemServer (
                szMachineNameArg,
                &pThisServer);
        } else {
            // make sure the server is really there
            // this is just a dummy call to see if the server will respond
            // with an error or RPC will respond with an error that there's
            // no server anymore.
            HRESULT hrTest;

            if (gp_GIT != NULL) {
                IWbemServices * pSvc = NULL;

                hrTest = gp_GIT->GetInterfaceFromGlobal(
                                pThisServer->dwCache,
                                IID_IWbemServices,
                                (void **) & pSvc);
                if (SUCCEEDED(hrTest)) {
                    if (pSvc != pThisServer->pSvc) {
                        DebugPrint((3,"GetInterfaceFromGlobal(0x%08X,%d,0x%08X,0x%08X)\n",
                                hrTest, pThisServer->dwCache, pThisServer->pSvc, pSvc));
                        pThisServer->pSvc = NULL;
                        if (pThisServer->pObjList != NULL) {
                            PPDHI_WBEM_OBJECT_DEF pObject;
                            PPDHI_WBEM_OBJECT_DEF pNext;
                            pObject = pThisServer->pObjList;
                            pThisServer->pObjList = NULL;
                            while (pObject != NULL) {
                                pNext = pObject->pNext;
                                G_FREE(pObject);
                                pObject = pNext;
                            }
                        }
                    }
                }
                else {
                    DebugPrint((3,"GetInterfaceFromGlobal(0x%08X,%d,0x%08X,0x%08X)\n",
                            hrTest, pThisServer->dwCache, pThisServer->pSvc, pSvc));
                    pThisServer->pSvc   = NULL;
                    if (pThisServer->pObjList != NULL) {
                        PPDHI_WBEM_OBJECT_DEF pObject;
                        PPDHI_WBEM_OBJECT_DEF pNext;
                        pObject = pThisServer->pObjList;
                        pThisServer->pObjList = NULL;
                        while (pObject != NULL) {
                            pNext = pObject->pNext;
                            G_FREE(pObject);
                            pObject = pNext;
                        }
                    }
                }
            }
            else {
                pThisServer->pSvc  = NULL;
                if (pThisServer->pObjList != NULL) {
                    PPDHI_WBEM_OBJECT_DEF pObject;
                    PPDHI_WBEM_OBJECT_DEF pNext;
                    pObject = pThisServer->pObjList;
                    pThisServer->pObjList = NULL;
                    while (pObject != NULL) {
                        pNext = pObject->pNext;
                        G_FREE(pObject);
                        pObject = pNext;
                    }
                }
            }
            if (pThisServer->pSvc != NULL) {
                hrTest = pThisServer->pSvc->CancelAsyncCall(NULL);
            } else {
                // there is no service connected so set the HRESULT to
                // get the next block to try and reconnect
                hrTest = 0x800706BF; // some bad status value thats NOT WBEM_E_INVALID_PARAMETER
            }

            // if the error is WBEM_E_INVALID_PARAMETER then the server is there
            // so we can continue
            // else if the error is something else then try to reconnect by closing and
            // reopening this connection

            if (hrTest != WBEM_E_INVALID_PARAMETER) {
                PdhiCloseWbemServer(pThisServer);
                pdhStatus = PdhiAddWbemServer (
                    szMachineNameArg,
                    &pThisServer);
            }
        }

        *pWbemServer = pThisServer;

        if (pdhStatus == ERROR_SUCCESS) pThisServer->lRefCount++;
    }

    if (szWideMachineName != NULL)  G_FREE (szWideMachineName);

    return pdhStatus;
}

PDH_FUNCTION
PdhiFreeAllWbemServers (
)
{
    PPDHI_WBEM_SERVER_DEF pThisServer;
    PPDHI_WBEM_SERVER_DEF pNextServer;

    pThisServer = pFirstWbemServer;
    while (pThisServer != NULL) {
        pNextServer = pThisServer->pNext;
        PdhiCloseWbemServer (pThisServer);
        G_FREE(pThisServer);
        pThisServer = pNextServer;
    }
    pFirstWbemServer = NULL;

    if (gp_GIT != NULL) {
        gp_GIT->Release();
        gp_GIT = NULL;
    }

    return ERROR_SUCCESS;
}

PDH_FUNCTION
PdhiGetWbemExplainText (
    IN  LPCWSTR     szMachineName,
    IN  LPCWSTR     szObjectName,
    IN  LPCWSTR     szCounterName,
    IN  LPWSTR      szExplain,
    IN  LPDWORD     pdwExplain
)
{
    PDH_STATUS Status      = ERROR_SUCCESS;
    HRESULT    hResult;
    BOOL       bDisconnect = FALSE;
    VARIANT    vsExplain;
    WCHAR      szObjectClassName[MAX_PATH];

    PPDHI_WBEM_SERVER_DEF   pThisServer = NULL;
    IEnumWbemClassObject  * pEnum       = NULL;
    IWbemClassObject      * pThisObject = NULL;
    IWbemQualifierSet     * pQualSet    = NULL;
    BOOL                    fCoInitialized = PdhiCoInitialize();

    if (szMachineName == NULL || szObjectName == NULL) {
        Status = PDH_INVALID_ARGUMENT;
    }
    if (szExplain != NULL && * pdwExplain != 0) {
        ZeroMemory(szExplain, * pdwExplain);
    }

    if (Status == ERROR_SUCCESS) {
        Status = PdhiConnectWbemServer(szMachineName, &pThisServer);
    }
    if (Status == ERROR_SUCCESS) {
        bDisconnect = TRUE;
        Status = PdhiWbemGetObjectClassName(
                pThisServer,
                szObjectName,
                szObjectClassName,
                MAX_PATH,
                & pThisObject);
    }

    if (Status == ERROR_SUCCESS) {
        VariantInit(& vsExplain);

        if (szCounterName != NULL) {
            SAFEARRAY * psaNames      = NULL;
            LONG        lLower        = 0; 
            LONG        lUpper        = 0;
            LONG        lCount        = 0;
            BSTR        bsPropName    = NULL;
            VARIANT     vName;
            VARIANT     vCountertype;
            LONG        lCounterType;

            VariantInit (& vName);
            VariantInit (& vCountertype);

            hResult = pThisObject->GetNames(
                        NULL,
                        WBEM_FLAG_NONSYSTEM_ONLY,
                        NULL,
                        & psaNames);
            if (hResult == WBEM_NO_ERROR) {
                hResult = SafeArrayGetLBound(psaNames, 1, & lLower);
                if (hResult == S_OK) {
                    hResult = SafeArrayGetUBound(psaNames, 1, & lUpper);
                }
                if (hResult == S_OK) {
                    for (lCount = lLower; lCount <= lUpper; lCount++) {
                        hResult = SafeArrayGetElement(
                                    psaNames,
                                    & lCount,
                                    & bsPropName);
                        if (hResult == S_OK) {
                            hResult = pThisObject->GetPropertyQualifierSet(
                                        bsPropName,
                                        & pQualSet);
                            if (hResult == S_OK) {
                                hResult = pQualSet->Get(
                                        cszCountertype,
                                        0,
                                        & vCountertype,
                                        NULL);
                                if (hResult == S_OK) {
                                    lCounterType = V_I4(& vCountertype);
                                    if (   ! (lCounterType & PERF_DISPLAY_NOSHOW)
                                        || (lCounterType == PERF_AVERAGE_BULK)) {
                                        hResult = pQualSet->Get(
                                                cszDisplayname,
                                                0,
                                                & vName,
                                                NULL);
                                        if (   hResult == S_OK
                                            && vName.vt == VT_BSTR) {
                                            if (lstrcmpiW(szCounterName,
                                                          V_BSTR(& vName)) == 0) {
                                                hResult = pQualSet->Get(
                                                        cszExplainText,
                                                        0,
                                                        & vsExplain,
                                                        NULL);
                                                if (   hResult == S_OK
                                                    && vsExplain.vt == VT_BSTR) {
                                                    LPWSTR szResult = V_BSTR(& vsExplain);
                                                    if (((DWORD) lstrlenW(szResult)) < (* pdwExplain)) {
                                                        lstrcpyW(szExplain, szResult);
                                                        Status = ERROR_SUCCESS;
                                                    }
                                                    else {
                                                        * pdwExplain = (DWORD) lstrlenW(szResult);
                                                        Status       = PDH_MORE_DATA;
                                                    }
                                                }
                                                pQualSet->Release();
                                                break;
                                            }
                                        }
                                    }
                                }
                                pQualSet->Release();
                            }
                        }
                        else {
                            SetLastError(hResult);
                            Status = PDH_WBEM_ERROR;
                        }
                    }
                }
                else {
                    SetLastError(hResult);
                    Status = PDH_WBEM_ERROR;
                }
            }
            else {
                SetLastError(hResult);
                Status = PDH_WBEM_ERROR;
            }
            VariantClear(& vName);
            VariantClear(& vCountertype);
        }
        else {
            // get counter object explain text
            //
            pThisObject->GetQualifierSet(& pQualSet);
            if (pQualSet != NULL) {
                hResult = pQualSet->Get(cszExplainText, 0, & vsExplain, 0);
                if (hResult == S_OK) {
                    LPWSTR szResult = V_BSTR(& vsExplain);
                    if (((DWORD) lstrlenW(szResult)) < (* pdwExplain)) {
                        lstrcpyW(szExplain, szResult);
                        Status = ERROR_SUCCESS;
                    }
                    else {
                        * pdwExplain = (DWORD) lstrlenW(szResult);
                        Status       = PDH_MORE_DATA;
                    }
                }
                else {
                    SetLastError(hResult);
                    Status = PDH_WBEM_ERROR;
                }
                pQualSet->Release();
            }
            else {
                SetLastError(WBEM_E_NOT_FOUND);
                Status = PDH_WBEM_ERROR;
            }
        }
        //pThisObject->Release();
        VariantClear(& vsExplain);
    }

    if (bDisconnect) {
        if (Status == ERROR_SUCCESS) {
            Status = PdhiDisconnectWbemServer(pThisServer);
        }
        else {
            PdhiDisconnectWbemServer(pThisServer);
        }
    }

    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }
    return Status;
}

PDH_FUNCTION
PdhiEnumWbemMachines (
    IN      LPVOID      pMachineList,
    IN      LPDWORD     pcchBufferSize,
    IN      BOOL        bUnicode
)
{
    PDH_STATUS  pdhStatus;
    PPDHI_WBEM_SERVER_DEF pThisServer = NULL;
    DWORD   dwCharsLeftInBuffer = *pcchBufferSize;
    DWORD   dwBufferSize = 0;
    DWORD   dwStrLen;
    DWORD   dwResult;

    assert (pcchBufferSize != NULL);

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

    // test to see if we've connected to the local machine yet, if not then do it
    if (pFirstWbemServer == NULL) {
        // add local machine
        pdhStatus = PdhiAddWbemServer (
            NULL,
            &pThisServer);
    }

    // walk down list of known machines and find the machines that are using
    // the specified name space.

    pThisServer = pFirstWbemServer;
    while (pThisServer != NULL) {
        dwStrLen = lstrlenW (pThisServer->szMachine) + 1;
        if ((pMachineList != NULL) && (dwCharsLeftInBuffer > dwStrLen)) {
            // then it will fit so add it
            dwResult = AddUniqueWideStringToMultiSz (
                pMachineList, pThisServer->szMachine, bUnicode);
            if (dwResult > 0) {
                dwBufferSize = dwResult;
                dwCharsLeftInBuffer = *pcchBufferSize - dwBufferSize;
            } // else
            // this string is already in the list so
            // nothing was added
        } else {
            // just add the string length to estimate the buffer size
            // required
            dwCharsLeftInBuffer = 0; // to prevent any other strings from being added
            dwBufferSize += dwStrLen;
        }
        pThisServer = pThisServer->pNext;
    }// end of while loop

    if (dwBufferSize <= *pcchBufferSize) {
        // the buffer size includes both term nulls
        pdhStatus = ERROR_SUCCESS;
    } else {
        // add terminating MSZ Null char size
        dwBufferSize++;
        // there wasn't enough room. See if a buffer was passed in
        pdhStatus = PDH_MORE_DATA;
    }
    // return the size used or required
    *pcchBufferSize = dwBufferSize;

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    return pdhStatus;
}

#pragma warning ( disable : 4127 )
PDH_FUNCTION
PdhiEnumWbemServerObjects(
    IN  PPDHI_WBEM_SERVER_DEF   pThisServer,
    IN  LPVOID                  mszObjectList,
    IN  LPDWORD                 pcchBufferSize,
    IN  DWORD                   dwDetailLevel,
    IN  BOOL                    bRefresh,       // ignored
    IN  BOOL                    bUnicode)
{
    // this function enumerates the classes that are subclassed
    // from the Win32_PerfRawData Superclass
    PDH_STATUS              pdhStatus = ERROR_SUCCESS;
    HRESULT                 hResult;
    DWORD                   dwCharsLeftInBuffer = *pcchBufferSize;
    DWORD                   dwBufferSize = 0;
    DWORD                   dwStrLen;
    DWORD                   dwRtnCount;
    DWORD                   dwResult;
    DWORD                   dwDetailLevelDesired;
    DWORD                   dwItemDetailLevel = 0;
    LPWSTR                  szClassName;
    VARIANT                 vName;
    VARIANT                 vClass;
    VARIANT                 vDetailLevel;
    BOOL                    bPerfDefault = FALSE;
    BSTR                    bsTemp = NULL;
    BSTR                    bsDisplayName = NULL;
    BSTR                    bsClass = NULL;
    BSTR                    bsCostly = NULL;
    BSTR                    bsDetailLevel = NULL;
    BSTR                    bsPerfDefault = NULL;

    BOOL                    bGetCostlyItems = FALSE;
    BOOL                    bIsCostlyItem = FALSE;
    BOOL                    bDisconnectServer = FALSE;

    IEnumWbemClassObject  * pEnum = NULL;
    IWbemClassObject      * pThisClass = NULL;
    IWbemQualifierSet     * pQualSet = NULL;

    PPDHI_WBEM_OBJECT_DEF   pHead   = NULL;
    PPDHI_WBEM_OBJECT_DEF   pObject = NULL;

    DBG_UNREFERENCED_PARAMETER(bRefresh);

    VariantInit(& vName);
    VariantInit(& vClass);
    VariantInit(& vDetailLevel);

    if (pThisServer->pObjList != NULL) {
        PPDHI_WBEM_OBJECT_DEF pObject = pThisServer->pObjList;
        PPDHI_WBEM_OBJECT_DEF pNext;

        pThisServer->pObjList = NULL;
        while (pObject != NULL) {
            pNext = pObject->pNext;
            if (pObject->pClass != NULL) pObject->pClass->Release();
            G_FREE(pObject);
            pObject = pNext;
        }
    }

    // create an enumerator of the PerfRawData class
    bsTemp = SysAllocString (cszPerfRawData);
    if (bsTemp) {
        hResult = pThisServer->pSvc->CreateClassEnum (
                bsTemp,
                WBEM_FLAG_DEEP | WBEM_FLAG_USE_AMENDED_QUALIFIERS,
                NULL,
                & pEnum);
        PdhiSysFreeString(&bsTemp);

        bDisconnectServer = TRUE;
        // Set security on the proxy
        if (SUCCEEDED(hResult))
        {
            hResult = SetWbemSecurity(pEnum);
        }

        if (hResult != WBEM_NO_ERROR) {
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // set costly flag
        bGetCostlyItems = ((dwDetailLevel & PERF_DETAIL_COSTLY) == PERF_DETAIL_COSTLY);
        dwDetailLevelDesired = (DWORD)(dwDetailLevel & PERF_DETAIL_STANDARD);
        bsCostly = SysAllocString (cszCostly);
        bsDisplayName = SysAllocString (cszDisplayname);
        bsClass = SysAllocString (cszClass);
        bsDetailLevel = SysAllocString (cszPerfdetail);
        bsPerfDefault = SysAllocString(cszPerfdefault);

        if (bsCostly && bsDisplayName && bsClass && bsDetailLevel) {
            while (TRUE) {
                hResult = pEnum->Next (
                    WBEM_INFINITE,      // timeout
                    1,      // return only 1 object
                    &pThisClass,
                    &dwRtnCount);

                // no more classes
                if ((pThisClass == NULL) || (dwRtnCount == 0)) break;

                // get the display name of this class
                bIsCostlyItem = FALSE; // assume it's not unless proven otherwise
                bPerfDefault  = FALSE;
                hResult = pThisClass->Get(bsClass, 0, & vClass, 0, 0);

                pThisClass->GetQualifierSet (&pQualSet);
                if (pQualSet != NULL) {
                    VariantClear (&vName);
                    hResult = pQualSet->Get (bsCostly, 0, &vName, 0);
                    if (hResult == S_OK) {
                        bIsCostlyItem = TRUE;
                    }
                    hResult = pQualSet->Get (bsDetailLevel, 0, &vDetailLevel, 0);
                    if (hResult == S_OK) {
                        dwItemDetailLevel = (DWORD)V_I4(&vDetailLevel);
                    } else {
                        dwItemDetailLevel = 0;
                    }

                    VariantClear(&vName);
                    hResult = pQualSet->Get(bsPerfDefault, 0, & vName, 0);
                    if (hResult != WBEM_E_NOT_FOUND) {
                        bPerfDefault = (BOOL) V_BOOL(& vName);
                    }

                    VariantClear(&vName);
                    hResult = pQualSet->Get(bsDisplayName, 0, & vName, 0);
                    pQualSet->Release();
                } else {
                    hResult = WBEM_E_NOT_FOUND;
                }

                if (hResult == WBEM_E_NOT_FOUND) {
                    // then this has not display name so
                    // pull the class name
                    hResult = pThisClass->Get(bsClass, 0, & vName, 0, 0);
                }

                if (hResult == WBEM_E_NOT_FOUND) {
                    szClassName = (LPWSTR) cszNotFound;
                } else {
                    szClassName = (LPWSTR) V_BSTR(&vName);
                }

                if (((bIsCostlyItem && bGetCostlyItems) || // if costly and we want them
                    (!bIsCostlyItem)) && (dwItemDetailLevel <= dwDetailLevelDesired)) {
                    dwStrLen = lstrlenW (szClassName) + 1;
                    if ((mszObjectList != NULL) && (dwCharsLeftInBuffer > dwStrLen)) {
                        // then it will fit so add it
                        dwResult = AddUniqueWideStringToMultiSz (
                            mszObjectList, szClassName, bUnicode);
                        if (dwResult > 0) {
                            dwBufferSize = dwResult;
                            dwCharsLeftInBuffer = *pcchBufferSize - dwBufferSize;
                        } // else
                    } else {
                        // just add the string length to estimate the buffer size
                        // required
                        dwCharsLeftInBuffer = 0; // to prevent any other strings from being added
                        dwBufferSize += dwStrLen;
                    }
                }

                if (lstrcmpiW(szClassName, cszNotFound) != 0) {
                    LPWSTR szClass = (LPWSTR) V_BSTR(& vClass);
                    DWORD dwSize   = sizeof(PDHI_WBEM_OBJECT_DEF)
                                   + sizeof(WCHAR) * (  lstrlenW(szClassName)
                                                      + lstrlenW(szClass) + 2);
                    pObject = (PPDHI_WBEM_OBJECT_DEF) G_ALLOC(dwSize);
                    if (pObject != NULL) {
                        pObject->bDefault  = bPerfDefault;
                        pObject->szObject  = (LPWSTR) (((LPBYTE) pObject)
                                           + sizeof(PDHI_WBEM_OBJECT_DEF));
                        lstrcpyW(pObject->szObject, szClass);
                        pObject->szDisplay = (LPWSTR) (((LPBYTE) pObject)
                                           + sizeof(PDHI_WBEM_OBJECT_DEF)
                                           + sizeof(WCHAR) * (lstrlenW(szClass) + 1));
                        lstrcpyW(pObject->szDisplay, szClassName);
                        pObject->pNext = pHead;
                        pHead          = pObject;
                    }
                    else {
                        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                        pThisClass->Release();
                        break;
                    }
                }

                // clear the variant
                VariantClear(& vName);
                VariantClear(& vClass);
                VariantClear(& vDetailLevel);

                // free this class
                pThisClass->Release();
            }
            dwBufferSize ++; // the final NULL

            if (dwBufferSize <= *pcchBufferSize) {
                pdhStatus = ERROR_SUCCESS;
            } else {
                // there wasn't enough room. See if a buffer was passed in
                pdhStatus = PDH_MORE_DATA;
            }
            // return the size used or required
            *pcchBufferSize = dwBufferSize;
        }
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    PdhiSysFreeString(& bsDisplayName);
    PdhiSysFreeString(& bsClass);
    PdhiSysFreeString(& bsCostly);
    PdhiSysFreeString(& bsDetailLevel);
    PdhiSysFreeString(& bsPerfDefault);

    VariantClear(& vName);
    VariantClear(& vClass);
    VariantClear(& vDetailLevel);

    if (pEnum != NULL) pEnum->Release();

    if (pdhStatus == ERROR_SUCCESS || pdhStatus == PDH_MORE_DATA) {
        pThisServer->pObjList = pHead;
    }
    else {
        pObject = pHead;
        while (pObject != NULL) {
            pHead   = pObject->pNext;
            G_FREE(pObject);
            pObject = pHead;
        }
    }

    if (bDisconnectServer) {
        if (pdhStatus == ERROR_SUCCESS) {
            pdhStatus = PdhiDisconnectWbemServer (pThisServer);
        } else {
            // keep error code from function body
            PdhiDisconnectWbemServer (pThisServer);
        }
    }

    return pdhStatus;
}

PDH_FUNCTION
PdhiEnumWbemObjects(
    IN  LPCWSTR     szWideMachineName,
    IN  LPVOID      mszObjectList,
    IN  LPDWORD     pcchBufferSize,
    IN  DWORD       dwDetailLevel,
    IN  BOOL        bRefresh,       // ignored
    IN  BOOL        bUnicode)
{
    PDH_STATUS             pdhStatus;
    PPDHI_WBEM_SERVER_DEF  pThisServer;
    BOOL                   fCoInitialized = PdhiCoInitialize();

    pdhStatus = PdhiConnectWbemServer(szWideMachineName, & pThisServer);
    if (pdhStatus == ERROR_SUCCESS) {
        pdhStatus = PdhiEnumWbemServerObjects(pThisServer,
                                              mszObjectList,
                                              pcchBufferSize,
                                              dwDetailLevel,
                                              bRefresh,
                                              bUnicode);
    }

    if (fCoInitialized) {
        PdhiCoUninitialize();
    }

    return pdhStatus;
}

PDH_FUNCTION
PdhiGetDefaultWbemObject (
    IN  LPCWSTR     szMachineName,
    IN  LPVOID      szDefaultObjectName,
    IN  LPDWORD     pcchBufferSize,
    IN  BOOL        bUnicode)
{
    // walk down the list of WBEM perf classes and find the one with the
    // default qualifier

    PDH_STATUS              pdhStatus;
    PPDHI_WBEM_SERVER_DEF   pThisServer;
    HRESULT                 hResult;
    DWORD                   dwBufferSize = 0;
    DWORD                   dwStrLen;
    BOOL                    bDisconnectServer = FALSE;

    // CoInitialize() if we need to
    BOOL fCoInitialized = PdhiCoInitialize();

    pdhStatus = PdhiConnectWbemServer (
        szMachineName,
        &pThisServer);

    if (pdhStatus == ERROR_SUCCESS) {
        bDisconnectServer = TRUE;
        if (pThisServer->pObjList == NULL) {
            DWORD dwSize = 0;
            pdhStatus = PdhiEnumWbemServerObjects(
                            pThisServer,
                            NULL,
                            & dwSize,
                            PERF_DETAIL_WIZARD | PERF_DETAIL_COSTLY,
                            TRUE,
                            TRUE);
            if (pThisServer->pObjList != NULL) {
                pdhStatus = ERROR_SUCCESS;
            }
        }

        if (pThisServer->pObjList != NULL) {
            PPDHI_WBEM_OBJECT_DEF pObject = pThisServer->pObjList;

            pdhStatus = PDH_CSTATUS_NO_OBJECT;
            while (pObject != NULL) {
                if (pObject->bDefault) {
                    pdhStatus = ERROR_SUCCESS;
                    if (bUnicode) {
                        dwStrLen = lstrlenW(pObject->szDisplay);
                        if (   szDefaultObjectName != NULL
                            && dwStrLen < * pcchBufferSize) {
                            lstrcpyW((LPWSTR) szDefaultObjectName,
                                     pObject->szDisplay);
                        }
                        else {
                            pdhStatus = PDH_MORE_DATA;
                        }
                        dwBufferSize = dwStrLen + 1;
                    }
                    else {
                        dwStrLen = * pcchBufferSize;
                        pdhStatus = PdhiConvertUnicodeToAnsi( _getmbcp(),
                                        pObject->szDisplay,
                                        (LPSTR) szDefaultObjectName,
                                        & dwStrLen);
                        dwBufferSize = dwStrLen;
                    }
                }
                pObject = pObject->pNext;
            }
        }
    }

    // return the size used or required
    * pcchBufferSize = dwBufferSize;

    if (bDisconnectServer) {
        if (pdhStatus == ERROR_SUCCESS) {
            pdhStatus = PdhiDisconnectWbemServer (pThisServer);
        } else {
            // keep error code from function body
            PdhiDisconnectWbemServer (pThisServer);
        }
    }

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    return pdhStatus;
}

PDH_FUNCTION
PdhiEnumWbemObjectItems (
    IN LPCWSTR      szWideMachineName,
    IN LPCWSTR      szWideObjectName,
    IN LPVOID       mszCounterList,
    IN LPDWORD      pcchCounterListLength,
    IN LPVOID       mszInstanceList,
    IN LPDWORD      pcchInstanceListLength,
    IN DWORD        dwDetailLevel,
    IN DWORD        dwFlags,
    IN BOOL         bUnicode
)
{
    PDH_STATUS          pdhStatus      = ERROR_SUCCESS;
    PDH_STATUS          CounterStatus  = ERROR_SUCCESS;
    PDH_STATUS          InstanceStatus = ERROR_SUCCESS;
    DWORD               dwStrLen;
    PPDHI_WBEM_SERVER_DEF   pThisServer;
    HRESULT                 hResult;
    DWORD               dwReturnCount;
    DWORD               dwCounterStringLen = 0;
    DWORD               dwInstanceStringLen = 0;
    LPWSTR              szNextWideString = NULL;
    LPSTR               szNextAnsiString = NULL;
    WCHAR               szObjectClassName[MAX_PATH];
    BSTR                bsName = NULL;
    BSTR                bsClassName = NULL;
    BOOL                bSingletonClass = FALSE;
    VARIANT             vName;
    DWORD               bDisconnectServer = FALSE;

    IWbemClassObject        *pThisClass = NULL;
    IWbemQualifierSet       *pQualSet = NULL;

    DBG_UNREFERENCED_PARAMETER (dwFlags);

    assert (szWideObjectName != NULL);
    assert (pcchCounterListLength != NULL);
    assert (pcchInstanceListLength != NULL);

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

    pdhStatus = PdhiConnectWbemServer (
        szWideMachineName,
        &pThisServer);

    // enumerate the instances
    if (pdhStatus == ERROR_SUCCESS) {
        pdhStatus = PdhiWbemGetObjectClassName (
            pThisServer,
            szWideObjectName,
            &szObjectClassName[0],
            sizeof(szObjectClassName) / sizeof(szObjectClassName[0]),
            &pThisClass);

        assert (pThisClass != NULL);

        bDisconnectServer = TRUE;

        if (pdhStatus == ERROR_SUCCESS) {
            bSingletonClass = PdhiIsSingletonClass (pThisClass);
        } else if (pThisClass == NULL) {
            pdhStatus = PDH_CSTATUS_NO_OBJECT;
        } else {
            // unable to find matching perf class
            // return status returned by method
        }
    }

    //enumerate the counter properties

    if (pdhStatus == ERROR_SUCCESS) {
        SAFEARRAY   *psaNames = NULL;
        long        lLower; 
        long        lUpper = 0;
        long        lCount;
        BSTR        bsPropName = NULL;
        BSTR        bsCountertype = NULL;
        BSTR        bsDisplayname = NULL;
        BSTR        bsDetailLevel = NULL;
        VARIANT     vCountertype;
        VARIANT     vDetailLevel;
        DWORD       dwItemDetailLevel;

        VariantInit (&vName);
        VariantInit (&vCountertype);
        VariantInit (&vDetailLevel);

        assert (pThisClass != NULL);

        dwDetailLevel &= PERF_DETAIL_STANDARD; // mask off any inappropriate bits

        // get the properties of this class as a Safe Array
        hResult = pThisClass->GetNames (NULL,
            WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
        if (hResult == WBEM_NO_ERROR) {
            hResult = SafeArrayGetLBound (psaNames, 1, &lLower);
            if (hResult == S_OK) {
                hResult = SafeArrayGetUBound (psaNames, 1, &lUpper);
            }
            if (hResult == S_OK) {
                szNextAnsiString = (LPSTR)mszCounterList;
                szNextWideString = (LPWSTR)mszCounterList;
                bsCountertype = SysAllocString (cszCountertype);
                bsDisplayname = SysAllocString (cszDisplayname);
                bsDetailLevel = SysAllocString (cszPerfdetail);
                if (bsCountertype && bsDisplayname && bsDetailLevel) {
                    for (lCount = lLower; lCount <= lUpper; lCount++) {
                        hResult = SafeArrayGetElement (psaNames, &lCount, &bsPropName);
                        if (hResult == S_OK) {
                            // get the qualifier set for this property
                            hResult = pThisClass->GetPropertyQualifierSet (
                                bsPropName, &pQualSet);
                            if (hResult == WBEM_NO_ERROR) {
                                LONG    lCounterType;
                                hResult = pQualSet->Get (bsDetailLevel, 0, &vDetailLevel, 0);
                                if (hResult == S_OK) {
                                    dwItemDetailLevel = (DWORD)V_I4(&vDetailLevel);
                                } else {
                                    dwItemDetailLevel = 0;
                                }

                                // make sure this is a perf counter property
                                hResult = pQualSet->Get (bsCountertype, 0, &vCountertype, NULL);
                                if (hResult == WBEM_NO_ERROR) {
                                    lCounterType = V_I4(&vCountertype);
                                    // then see if this is a displayable counter
                                    if ((!(lCounterType & PERF_DISPLAY_NOSHOW) ||
                                         (lCounterType == PERF_AVERAGE_BULK)) &&
                                        (dwItemDetailLevel <= dwDetailLevel)) {
                                        // by testing for the counter type
                                        // get the display name for this property
                                        hResult = pQualSet->Get (bsDisplayname, 0, &vName, NULL);
                                        if (hResult == WBEM_NO_ERROR && vName.vt == VT_BSTR) {
                                            // display name found
                                            if (bUnicode) {
                                                dwStrLen = lstrlenW (V_BSTR(&vName)) + 1;
                                                if (   (mszCounterList != NULL)
                                                    && (   (dwCounterStringLen + dwStrLen)
                                                        <= (* pcchCounterListLength))) {
                                                    lstrcpyW (szNextWideString, V_BSTR(&vName));
                                                    szNextWideString += dwStrLen;
                                                }
                                                else {
                                                    pdhStatus = PDH_MORE_DATA;
                                                }
                                            } else {
                                                dwStrLen = (dwCounterStringLen < * pcchCounterListLength)
                                                         ? (* pcchCounterListLength - dwCounterStringLen)
                                                         : (0);
                                                 pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                                         V_BSTR(& vName), szNextAnsiString, & dwStrLen);
                                                 if (pdhStatus == ERROR_SUCCESS) {
                                                    szNextAnsiString += dwStrLen;
                                                 }
                                            }
                                            dwCounterStringLen += dwStrLen;
                                        }
                                    } else {
                                        // this is a "don't show" counter so skip it
                                    }
                                } else {
                                    // unable to get the counter type so it's probably
                                    // not a perf counter property, skip it and continue
                                }
                                VariantClear (&vName);
                                VariantClear (&vCountertype);
                                VariantClear (&vDetailLevel);

                                pQualSet->Release();
                            } else {
                                // no properties so continue with the next one
                            }
                        } else {
                            // unable to read element in SafeArray
                            pdhStatus = PDH_WBEM_ERROR;
                            SetLastError(hResult);
                        }
                    } // end for each element in SafeArray
                } else {
                    pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                }
                PdhiSysFreeString (&bsCountertype);
                PdhiSysFreeString (&bsDisplayname);
                PdhiSysFreeString (&bsDetailLevel);
            } else {
                // unable to get array boundries
                pdhStatus = PDH_WBEM_ERROR;
                SetLastError (hResult);
            }
        } else {
            // unable to get property strings
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }

        dwCounterStringLen ++; // final NULL for MSZ
        if (dwCounterStringLen > * pcchCounterListLength) {
            pdhStatus = PDH_MORE_DATA;
        }

        if (pdhStatus == ERROR_SUCCESS) {
            if (bUnicode) {
                if (szNextWideString != NULL) {
                    if (szNextWideString != (LPWSTR)mszCounterList) {
                        *szNextWideString++ = 0;
                    } else {
                        // nothing returned
                        dwCounterStringLen = 0;
                    }
                } else {
                    // then this is just a length query so return
                    // include the the MSZ term null char
                    CounterStatus = PDH_MORE_DATA;
                }
            } else {
                if (szNextAnsiString != NULL) {
                    if (szNextAnsiString != (LPSTR)mszCounterList) {
                        *szNextAnsiString ++ = 0;
                    } else {
                        dwCounterStringLen = 0;
                    }
                } else {
                    // then this is just a length query so return
                    // include the the MSZ term null char
                    CounterStatus = PDH_MORE_DATA;
                }
            }
        }
        else {
            CounterStatus = pdhStatus;
        }

        VariantClear (&vName);
        VariantClear (&vCountertype);
        VariantClear (&vDetailLevel);

                // Clear the SafeArray if it exists
        if ( NULL != psaNames )
        {
            SafeArrayDestroy( psaNames );
            psaNames = NULL;
        }

        *pcchCounterListLength = dwCounterStringLen;

        //pThisClass->Release();
    }

    // Get instance strings if necessary

    if (pdhStatus == ERROR_SUCCESS || pdhStatus == PDH_MORE_DATA) {
        szNextAnsiString = (LPSTR)  mszInstanceList;
        szNextWideString = (LPWSTR) mszInstanceList;

        if (!bSingletonClass) {
            IWbemRefresher           * pRefresher    = NULL;
            IWbemConfigureRefresher  * pConfig       = NULL;
            IWbemHiPerfEnum          * pEnum         = NULL;
            LONG                       lID;
            DWORD                      dwNumReturned = 1;
            DWORD                      dwNumObjects  = 0;
            DWORD                      i;
            IWbemObjectAccess       ** apEnumAccess  = NULL;
            CIMTYPE                    cimType;
            WCHAR                      szName[SMALL_BUFFER_SIZE];
            LONG                       lNameHandle   = -1;
            LONG                       lSize1        = SMALL_BUFFER_SIZE;
            LONG                       lSize2        = 0;

            hResult = CoCreateInstance(CLSID_WbemRefresher,
                                       NULL,
                                       CLSCTX_INPROC_SERVER,
                                       IID_IWbemRefresher,
                                       (void **) & pRefresher);
            if (SUCCEEDED(hResult)) {
                hResult = pRefresher->QueryInterface(
                                IID_IWbemConfigureRefresher,
                                (void **) & pConfig);
                if (SUCCEEDED(hResult)) {
                    hResult = pConfig->AddEnum(pThisServer->pSvc,
                                               szObjectClassName,
                                               0,
                                               NULL,
                                               & pEnum,
                                               & lID);
                    if (SUCCEEDED(hResult)) {
                        hResult = pRefresher->Refresh(0L);
                        if (SUCCEEDED(hResult)) {
                            hResult = pEnum->GetObjects(0L,
                                                        dwNumObjects,
                                                        apEnumAccess,
                                                        & dwNumReturned);
                            if (hResult == WBEM_E_BUFFER_TOO_SMALL) {
                                apEnumAccess = (IWbemObjectAccess **)
                                        G_ALLOC(dwNumReturned
                                                * sizeof(IWbemObjectAccess *));
                                if (apEnumAccess != NULL) {
                                    ZeroMemory(apEnumAccess, dwNumReturned
                                             * sizeof(IWbemObjectAccess *));
                                    dwNumObjects = dwNumReturned;
                                    hResult = pEnum->GetObjects(0L,
                                                            dwNumObjects,
                                                            apEnumAccess,
                                                            & dwNumReturned);
                                }
                                else {
                                    hResult = WBEM_E_OUT_OF_MEMORY;
                                }
                            }
                            if (SUCCEEDED(hResult)) {
                                for (i = 0; i < dwNumReturned; i ++) {
                                    hResult = apEnumAccess[i]->GetPropertyHandle(
                                                    cszName,
                                                    & cimType,
                                                    & lNameHandle);
                                    if (SUCCEEDED(hResult) && lNameHandle != -1) {
                                        ZeroMemory(szName,
                                                   SMALL_BUFFER_SIZE * sizeof(WCHAR));
                                        hResult = apEnumAccess[i]->ReadPropertyValue(
                                                lNameHandle,
                                                lSize1,
                                                & lSize2,
                                                (LPBYTE) szName);
                                        if (SUCCEEDED(hResult) && lstrlenW(szName) > 0) {
                                            if (bUnicode) {
                                                dwStrLen = lstrlenW(szName) + 1;
                                                if (   (mszInstanceList != NULL)
                                                    && (   (dwInstanceStringLen + dwStrLen)
                                                         < (* pcchInstanceListLength))) {
                                                    lstrcpyW (szNextWideString, szName);
                                                    szNextWideString += dwStrLen;
                                                }
                                                else {
                                                    pdhStatus = PDH_MORE_DATA;
                                                }
                                            }
                                            else {
                                                dwStrLen = (dwInstanceStringLen <= * pcchInstanceListLength)
                                                         ? (* pcchInstanceListLength - dwInstanceStringLen)
                                                         : (0);
                                                pdhStatus = PdhiConvertUnicodeToAnsi(
                                                        _getmbcp(),
                                                        szName,
                                                        szNextAnsiString,
                                                        & dwStrLen);
                                                if (pdhStatus == ERROR_SUCCESS) {
                                                    szNextAnsiString += dwStrLen;
                                                }
                                            }
                                            dwInstanceStringLen += dwStrLen;
                                        }
                                    }
                                    apEnumAccess[i]->Release();
                                }
                            }
                        }
                    }
                }
            }

            if (! SUCCEEDED(hResult)) {
                SetLastError(hResult);
                pdhStatus = PDH_WBEM_ERROR;
            }
            else if (dwInstanceStringLen == 0) {
                dwInstanceStringLen = 2;
                if (   szNextWideString != NULL
                    && dwInstanceStringLen <= * pcchInstanceListLength) {
                    * szNextWideString = L'\0';
                    szNextWideString ++;
                }
                if (   szNextAnsiString != NULL
                    && dwInstanceStringLen <= * pcchInstanceListLength) {
                    * szNextAnsiString = '\0';
                    szNextAnsiString ++;
                }
            }
            else {
                dwInstanceStringLen ++;
            }

            if (apEnumAccess != NULL) G_FREE(apEnumAccess);
            if (pEnum        != NULL) pEnum->Release();
            if (pConfig      != NULL) pConfig->Release();
            if (pRefresher   != NULL) pRefresher->Release();
        }

        if (dwInstanceStringLen > * pcchInstanceListLength) {
            pdhStatus = PDH_MORE_DATA;
        }
        if (pdhStatus == ERROR_SUCCESS) {
            if (bUnicode) {
                if (szNextWideString != NULL) {
                    if (szNextWideString != (LPWSTR)mszInstanceList) {
                        *szNextWideString++ = 0;
                    } else {
                        dwInstanceStringLen = 0;
                    }
                } else if (dwInstanceStringLen > 0) {
                    // then this is just a length query so return
                    // include the the MSZ term null char
                    InstanceStatus = PDH_MORE_DATA;
                }
            } else {
                if (szNextAnsiString != NULL) {
                    if (szNextAnsiString != (LPSTR)mszInstanceList) {
                        *szNextAnsiString++ = 0;
                    } else {
                        dwInstanceStringLen = 0;
                    }
                } else if (dwInstanceStringLen > 0) {
                    // then this is just a length query so return
                    // include the the MSZ term null char
                    InstanceStatus = PDH_MORE_DATA;
                }
            }
        }
        else {
            InstanceStatus = pdhStatus;
        }
        *pcchInstanceListLength = dwInstanceStringLen;
    }

    VariantClear (&vName);

    if (bDisconnectServer) {
        if (pdhStatus == ERROR_SUCCESS) {
            pdhStatus = PdhiDisconnectWbemServer (pThisServer);
        } else {
            // keep error code from function body
            PdhiDisconnectWbemServer (pThisServer);
        }
    }

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    if (pdhStatus == ERROR_SUCCESS) {
        pdhStatus = (CounterStatus == ERROR_SUCCESS)
                  ? (InstanceStatus) : (CounterStatus);
    }

    return pdhStatus;
}
#pragma warning ( default : 4127 )

PDH_FUNCTION
PdhiGetDefaultWbemProperty (
    IN LPCWSTR      szMachineName,
    IN LPCWSTR      szObjectName,
    IN LPVOID       szDefaultCounterName,
    IN LPDWORD      pcchBufferSize,
    IN BOOL         bUnicode
)
{
    PDH_STATUS          pdhStatus = ERROR_SUCCESS;
    DWORD               dwStrLen;
    PPDHI_WBEM_SERVER_DEF   pThisServer;
    HRESULT                 hResult;
    DWORD               dwCounterStringLen = 0;
    WCHAR               szObjectClassName[MAX_PATH];
    DWORD               bDisconnectServer = FALSE;
    BOOL                bFound = FALSE;

    IWbemClassObject        *pThisClass = NULL;
    IWbemQualifierSet       *pQualSet = NULL;

    assert (szMachineName != NULL);
    assert (szObjectName != NULL);
    assert (pcchBufferSize != NULL);

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

    pdhStatus = PdhiConnectWbemServer (
        szMachineName,
        &pThisServer);

    // enumerate the instances
    if (pdhStatus == ERROR_SUCCESS) {
        pdhStatus = PdhiWbemGetObjectClassName (
            pThisServer,
            szObjectName,
            &szObjectClassName[0],
            sizeof(szObjectClassName) / sizeof(szObjectClassName[0]),
            &pThisClass);
        bDisconnectServer = TRUE;
    }

    //enumerate the counter properties

    if (pdhStatus == ERROR_SUCCESS) {
        SAFEARRAY   *psaNames = NULL;
        long        lLower; 
        long        lUpper = 0;
        long        lCount;
        BSTR        bsPropName = NULL;
        BSTR        bsDisplayname = NULL;
        BSTR        bsPerfDefault = NULL;
        VARIANT     vName, vCountertype;

        VariantInit (&vName);
        VariantInit (&vCountertype);

        // get the properties of this class as a Safe Array
        hResult = pThisClass->GetNames (NULL,
            WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
        if (hResult == WBEM_NO_ERROR) {
            hResult = SafeArrayGetLBound (psaNames, 1, &lLower);
            if (hResult == S_OK) {
                hResult = SafeArrayGetUBound (psaNames, 1, &lUpper);
            }
            if (hResult == S_OK) {
                bsDisplayname = SysAllocString (cszDisplayname);
                bsPerfDefault = SysAllocString (cszPerfdefault);
                if (bsDisplayname && bsPerfDefault) {
                    for (lCount = lLower; lCount <= lUpper; lCount++) {
                        hResult = SafeArrayGetElement (psaNames, &lCount, &bsPropName);
                        if (hResult == S_OK) {
                            // get the qualifier set for this property
                            hResult = pThisClass->GetPropertyQualifierSet (
                                bsPropName, &pQualSet);
                            if (hResult == WBEM_NO_ERROR) {
                                // make sure this is a perf counter property
                                hResult = pQualSet->Get (bsPerfDefault, 0, &vCountertype, NULL);
                                if (hResult == WBEM_NO_ERROR) {
                                    if ((BOOL)V_BOOL(&vCountertype)) {
                                        // found the default property so load it and return
                                        hResult = pQualSet->Get (bsDisplayname, 0, &vName, NULL);
                                        if (hResult == WBEM_NO_ERROR) {
                                            // display name found
                                            bFound = TRUE;
                                            if (bUnicode) {
                                                dwStrLen = lstrlenW (V_BSTR(&vName)) + 1;
                                                if (   (szDefaultCounterName != NULL)
                                                    && (dwStrLen <= * pcchBufferSize)) {
                                                    lstrcpyW ((LPWSTR)szDefaultCounterName,
                                                              (LPWSTR)V_BSTR(&vName));
                                                }
                                                else {
                                                    pdhStatus = PDH_MORE_DATA;
                                                }
                                            }
                                            else {
                                                dwStrLen = * pcchBufferSize;
                                                pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                                        (LPWSTR) V_BSTR(& vName),
                                                        (LPSTR)  szDefaultCounterName,
                                                        & dwStrLen);
                                            }
                                            // this is either the amount used or the amount needed
                                            dwCounterStringLen = dwStrLen;
                                            // free qualifier set
                                            pQualSet->Release();
                                            // now leave
                                            break;
                                        } else {
                                            // no qualifier so assume FALSE
                                        }
                                    } else {
                                        // value found but is FALSE
                                    }
                                }
                                // free the qualifier set
                                pQualSet->Release();
                                // clear variants
                                VariantClear (&vName);
                                VariantClear (&vCountertype);
                            } else {
                                // no Qualifiers so continue with the next one
                            }
                        } else {
                            // unable to read element in SafeArray
                            pdhStatus = PDH_WBEM_ERROR;
                            SetLastError(hResult);
                        }
                    } // end for each element in SafeArray
                } else {
                    pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                }
                // no default defined for this object
                if ((pdhStatus == ERROR_SUCCESS) && !bFound) pdhStatus = PDH_CSTATUS_NO_COUNTER;

                PdhiSysFreeString (&bsPerfDefault);
                PdhiSysFreeString (&bsDisplayname);
            } else {
                // unable to get array boundries
                pdhStatus = PDH_WBEM_ERROR;
                SetLastError (hResult);
            }
        } else {
            // unable to get property strings
            pdhStatus = PDH_WBEM_ERROR;
            SetLastError (hResult);
        }

        if ( NULL != psaNames )
        {
            SafeArrayDestroy( psaNames );
        }

        VariantClear (&vName);
        VariantClear (&vCountertype);

        //pThisClass->Release();
    }
    *pcchBufferSize = dwCounterStringLen;

    if (bDisconnectServer) {
        if (pdhStatus == ERROR_SUCCESS) {
            pdhStatus = PdhiDisconnectWbemServer (pThisServer);
        } else {
            // keep error code from function body
            PdhiDisconnectWbemServer (pThisServer);
        }
    }

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    return pdhStatus;
}

PDH_FUNCTION
PdhiEncodeWbemPathW (
    IN      PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElements,
    IN      LPWSTR                      szFullPathBuffer,
    IN      LPDWORD                     pcchBufferSize,
    IN      LANGID                      LangId,
    IN      DWORD                       dwFlags
)
/*++

  converts a set of path elements in either Registry or WBEM format
  to a path in either Registry or WBEM format as defined by the flags.

--*/
{
    PDH_STATUS  pdhStatus = ERROR_SUCCESS;
    DWORD       dwBuffSize;
    LPWSTR      szTempPath = NULL;
    DWORD       dwCurSize = 0;

    LPWSTR      szThisChar;
    IWbemClassObject        *pWbemClass = NULL;
    PPDHI_WBEM_SERVER_DEF   pWbemServer = NULL;
    DWORD                   bDisconnectServer = FALSE;

    DBG_UNREFERENCED_PARAMETER (LangId);

    assert (pCounterPathElements != NULL); // this is not allowed
    assert (dwFlags != 0); // this should be caught by the calling fn.
    assert (pcchBufferSize != NULL); // this is required

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

    // create a working buffer the same size as the one passed in

    if (*pcchBufferSize == 0L) {
        dwBuffSize = *pcchBufferSize * sizeof(WCHAR);
    } else {
        dwBuffSize = 1024 * sizeof(WCHAR); // just something to work with
    }

    szTempPath = (LPWSTR) G_ALLOC(dwBuffSize);

    if (szTempPath == NULL) {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    } else if (pdhStatus == ERROR_SUCCESS) {
        szTempPath[0] = L'\0';
        // start by adding the machine name to the path
        if (pCounterPathElements->szMachineName != NULL) {
            lstrcpyW (szTempPath, pCounterPathElements->szMachineName);
            if (dwFlags == (PDH_PATH_WBEM_INPUT)) {
                // if this is a wbem element in to a registry path out,
                // then remove the namespace which occurs starting at the
                // second backslash
                for (szThisChar = &szTempPath[2];
                    (*szThisChar != 0) && (*szThisChar != L'\\');
                    szThisChar++);
                if (*szThisChar != 0) *szThisChar = 0;
            } else if (dwFlags == (PDH_PATH_WBEM_RESULT)) {
                // if this is a registry element in to a WBEM out, then
                // append the default namespace to the machine name
//NAMEFIX                lstrcatW (szTempPath, cszWbemDefaultPerfRoot);
            }
        } else {
            // no machine name specified so add the default machine
            // and default namespace for a wbem output path
            if (dwFlags == (PDH_PATH_WBEM_RESULT)) {
                lstrcpyW (szTempPath, cszDoubleBackSlashDot); // default machine
//NAMEFIX                lstrcatW (szTempPath, cszWbemDefaultPerfRoot);
            } else {
                // no entry required for the registry path
            }
        }
        dwCurSize = lstrlenW(szTempPath);

        // now add the object or class name
        if (pdhStatus == ERROR_SUCCESS) {
            if (pCounterPathElements->szObjectName != NULL) {
                DWORD   dwSize;
                WCHAR   szTempObjectString[1024];
    
                dwSize = 1024;
                ZeroMemory(szTempObjectString, sizeof(WCHAR) * 1024);
                // then the input is different from the output
                // so convert from one to the other
                // and default name space since perf counters won't be
                // found elsewhere
                pdhStatus = PdhiConnectWbemServer (
                    NULL, // use local machine
                    &pWbemServer);
                if (pdhStatus == ERROR_SUCCESS) {
                    bDisconnectServer = TRUE;
                    if (dwFlags & PDH_PATH_WBEM_INPUT) {
                        // convert the WBEM Class to the display name
                        pdhStatus = PdhiWbemGetClassDisplayName (
                            pWbemServer,
                            pCounterPathElements->szObjectName,
                            &szTempObjectString[0],
                            dwSize,
                            &pWbemClass);
                        // add a backslash path separator for registry output
                        if (pdhStatus == ERROR_SUCCESS) {
                            if (dwFlags & PDH_PATH_WBEM_RESULT) {
                                lstrcatW(szTempPath, cszColon);
                                // just copy the string, but save
                                lstrcpyW (szTempObjectString, pCounterPathElements->szObjectName);
                            } else {
                                lstrcatW(szTempPath, cszBackSlash);
                                // copy the retrieved string
                            }
                        }
                    } else {
                        // convert the display name to a Wbem class name
                        pdhStatus = PdhiWbemGetObjectClassName (
                            pWbemServer,
                            pCounterPathElements->szObjectName,
                            &szTempObjectString[0],
                            dwSize,
                            &pWbemClass);
                        // add a colon path separator
                        lstrcatW(szTempPath, cszColon);
                    }
                    if (pdhStatus == ERROR_SUCCESS) {
                        //then add the string
                        lstrcatW(szTempPath, szTempObjectString);
                        dwCurSize += lstrlenW(szTempObjectString) + 1; // includes delimiter
                    }

                    if (bDisconnectServer) {
                        if (pdhStatus == ERROR_SUCCESS) {
                            pdhStatus = PdhiDisconnectWbemServer (pWbemServer);
                        } else {
                            // keep error code from function body
                            PdhiDisconnectWbemServer (pWbemServer);
                        }
                    }
                }
            } else {
                // no object name, so bad structure
                pdhStatus = PDH_CSTATUS_NO_OBJECT;
            }

        }

        // check for instance entries to add before adding the counter.
        if (pdhStatus == ERROR_SUCCESS) {
            if (pCounterPathElements->szInstanceName != NULL) {
                lstrcatW (szTempPath, cszLeftParen);
                dwCurSize += 1;
                if (pCounterPathElements->szParentInstance != NULL) {
                    lstrcatW (szTempPath, pCounterPathElements->szParentInstance);
                    lstrcatW (szTempPath, cszSlash);
                    dwCurSize += lstrlenW( pCounterPathElements->szParentInstance ) + 1;
                }
                lstrcatW (szTempPath, pCounterPathElements->szInstanceName);
                lstrcatW (szTempPath, cszRightParen);
                dwCurSize += lstrlenW( pCounterPathElements->szInstanceName ) + 1;
            } else {
                // this is OK
                assert (pCounterPathElements->szParentInstance == NULL);
                assert (pCounterPathElements->dwInstanceIndex == 0);
            }
        }

        // add counter name
        if (pdhStatus == ERROR_SUCCESS) {
            if (pCounterPathElements->szCounterName != NULL) {
                DWORD   dwSize;
                WCHAR   szTempCounterString[1024];

                dwSize = 1024;
                // then the input is different from the output
                // so convert from one to the other
                // and default name space since perf counters won't be
                // found elsewhere
                assert (pWbemServer != NULL);
                if (pdhStatus == ERROR_SUCCESS) {
                    // add a backslash path separator
                    lstrcatW(szTempPath, cszBackSlash);
                    if (dwFlags & PDH_PATH_WBEM_INPUT) {
                        // convert the WBEM Class to the display name
                        pdhStatus = PdhiWbemGetCounterDisplayName (
                            pWbemClass,
                            pCounterPathElements->szCounterName,
                            &szTempCounterString[0],
                            dwSize);
                        if (dwFlags & PDH_PATH_WBEM_RESULT) {
                            // just copy the string, but save
                            // the class pointer
                            lstrcpyW (szTempCounterString, pCounterPathElements->szCounterName);
                        } else {
                            // copy the retrieved string
                        }
                    } else {
                        // convert the display name to a Wbem class name
                        pdhStatus = PdhiWbemGetCounterPropertyName (
                            pWbemClass,
                            pCounterPathElements->szCounterName,
                            &szTempCounterString[0],
                            dwSize);
                    }
                    if (pdhStatus == ERROR_SUCCESS) {
                        //then add the string
                        lstrcatW(szTempPath, szTempCounterString);
                        dwCurSize += lstrlenW(szTempCounterString) + 1; // includes delimiter
                    }
                }
            } else {
                // no object name, so bad structure
                pdhStatus = PDH_CSTATUS_NO_COUNTER;
            }
        }

        assert (dwCurSize == (DWORD)lstrlenW(szTempPath));
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // copy path to the caller's buffer if it will fit
        assert (dwCurSize == (DWORD)lstrlenW(szTempPath));
        if (dwCurSize < *pcchBufferSize) {
            if (szFullPathBuffer != NULL) {
                lstrcpyW (szFullPathBuffer, szTempPath);
            }
        } else {
            if (szFullPathBuffer != NULL) {
                // the buffer passed in is too small
                pdhStatus = PDH_MORE_DATA;
            }
        }
        *pcchBufferSize = dwCurSize;
    }

    //if (pWbemClass != NULL) pWbemClass->Release();

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }
    if (szTempPath != NULL) G_FREE(szTempPath);

    return pdhStatus;
}

PDH_FUNCTION
PdhiEncodeWbemPathA (
    PDH_COUNTER_PATH_ELEMENTS_A *pCounterPathElements,
    LPSTR                       szFullPathBuffer,
    LPDWORD                     pcchBufferSize,
    LANGID                      LangId,
    DWORD                       dwFlags
)
{
    PDH_STATUS                  pdhStatus = ERROR_SUCCESS;
    LPWSTR                      wszNextString;
    LPWSTR                      wszReturnBuffer;
    PDH_COUNTER_PATH_ELEMENTS_W *pWideCounterPathElements;
    DWORD                       dwcchBufferSize;
    DWORD                       dwBuffSize;
    DWORD                       dwDest;

    // get required buffer size...
    dwBuffSize = sizeof (PDH_COUNTER_PATH_ELEMENTS_W);

    if (pCounterPathElements->szMachineName != NULL) {
        dwBuffSize += (lstrlenA(pCounterPathElements->szMachineName) + 1) * sizeof(WCHAR);
    }

    if (pCounterPathElements->szObjectName != NULL) {
        dwBuffSize += (lstrlenA(pCounterPathElements->szObjectName) + 1) * sizeof(WCHAR);
    }

    if (pCounterPathElements->szInstanceName != NULL) {
        dwBuffSize += (lstrlenA(pCounterPathElements->szInstanceName) + 1) * sizeof(WCHAR);
    }

    if (pCounterPathElements->szParentInstance != NULL) {
        dwBuffSize += (lstrlenA(pCounterPathElements->szParentInstance) + 1) * sizeof(WCHAR);
    }

    if (pCounterPathElements->szCounterName != NULL) {
        dwBuffSize += (lstrlenA(pCounterPathElements->szCounterName) + 1) * sizeof(WCHAR);
    }

    // add in room for the return buffer
    dwcchBufferSize  = * pcchBufferSize;
    dwBuffSize      += dwcchBufferSize * sizeof(WCHAR);

    pWideCounterPathElements = (PDH_COUNTER_PATH_ELEMENTS_W *)G_ALLOC(dwBuffSize);

    if (pWideCounterPathElements != NULL) {
        // populate the fields
        wszNextString = (LPWSTR)&pWideCounterPathElements[1];

        if (pCounterPathElements->szMachineName != NULL) {
            dwDest = MultiByteToWideChar(_getmbcp(),
                        0,
                        pCounterPathElements->szMachineName,
                        lstrlenA(pCounterPathElements->szMachineName),
                        wszNextString,
                        (lstrlenA(pCounterPathElements->szMachineName) + 1));
            if (dwDest > 0) {
                pWideCounterPathElements->szMachineName = wszNextString;
                wszNextString += dwDest + 1;
            }
            else {
                pWideCounterPathElements->szMachineName = NULL;
            }
        } else {
            pWideCounterPathElements->szMachineName = NULL;
        }

        if (pCounterPathElements->szObjectName != NULL) {
            pWideCounterPathElements->szObjectName = wszNextString;
            dwDest = MultiByteToWideChar(_getmbcp(),
                        0,
                        pCounterPathElements->szObjectName,
                        lstrlenA(pCounterPathElements->szObjectName),
                        wszNextString,
                        (lstrlenA(pCounterPathElements->szObjectName) + 1));
            if (dwDest > 0) {
                pWideCounterPathElements->szObjectName = wszNextString;
                wszNextString += dwDest + 1;
            }
            else {
                pWideCounterPathElements->szObjectName = NULL;
            }
        } else {
            pWideCounterPathElements->szObjectName = NULL;
        }

        if (pCounterPathElements->szInstanceName != NULL) {
            dwDest = MultiByteToWideChar(_getmbcp(),
                        0,
                        pCounterPathElements->szInstanceName,
                        lstrlenA(pCounterPathElements->szInstanceName),
                        wszNextString,
                        (lstrlenA(pCounterPathElements->szInstanceName) + 1));
            if (dwDest > 0) {
                pWideCounterPathElements->szInstanceName = wszNextString;
                wszNextString += dwDest + 1;
            }
            else {
                pWideCounterPathElements->szInstanceName = NULL;
            }
        } else {
            pWideCounterPathElements->szInstanceName = NULL;
        }

        if (pCounterPathElements->szParentInstance != NULL) {
            dwDest = MultiByteToWideChar(_getmbcp(),
                        0,
                        pCounterPathElements->szParentInstance,
                        lstrlenA(pCounterPathElements->szParentInstance),
                        wszNextString,
                        (lstrlenA(pCounterPathElements->szParentInstance) + 1));
            if (dwDest > 0) {
                pWideCounterPathElements->szParentInstance = wszNextString;
                wszNextString += dwDest + 1;
            }
            else {
                pWideCounterPathElements->szParentInstance = NULL;
            }
        } else {
            pWideCounterPathElements->szParentInstance = NULL;
        }

        if (pCounterPathElements->szCounterName != NULL) {
            dwDest = MultiByteToWideChar(_getmbcp(),
                        0,
                        pCounterPathElements->szCounterName,
                        lstrlenA(pCounterPathElements->szCounterName),
                        wszNextString,
                        (lstrlenA(pCounterPathElements->szCounterName) + 1));
            if (dwDest > 0) {
                pWideCounterPathElements->szCounterName = wszNextString;
                wszNextString += dwDest + 1;
            }
            else {
                pWideCounterPathElements->szCounterName = NULL;
            }
        } else {
            pWideCounterPathElements->szCounterName = NULL;
        }

        pWideCounterPathElements->dwInstanceIndex =
            pCounterPathElements->dwInstanceIndex;

        if (szFullPathBuffer != NULL) {
            wszReturnBuffer = wszNextString;
        } else {
            wszReturnBuffer = NULL;
        }

        // call wide function
        pdhStatus = PdhiEncodeWbemPathW (
            pWideCounterPathElements,
            wszReturnBuffer,
            & dwcchBufferSize,
            LangId,
            dwFlags);

        if ((pdhStatus == ERROR_SUCCESS) && (szFullPathBuffer != NULL)) {
            // convert the wide path back to ANSI
            pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                        wszReturnBuffer,
                        szFullPathBuffer,
                        pcchBufferSize);
        }

        G_FREE (pWideCounterPathElements);
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    return pdhStatus;

}

PDH_FUNCTION
PdhiDecodeWbemPathW (
    IN      LPCWSTR                     szFullPathBuffer,
    IN      PDH_COUNTER_PATH_ELEMENTS_W *pCounterPathElements,
    IN      LPDWORD                     pdwBufferSize,
    IN      LANGID                      LangId,
    IN      DWORD                       dwFlags
)
{
    PPDHI_COUNTER_PATH  pLocalCounterPath;
    PDH_STATUS          pdhStatus = ERROR_SUCCESS;
    DWORD               dwSize;
    LPWSTR              szString = NULL;
    WCHAR               wszTempBuffer[MAX_PATH];
    LPWSTR              szSrc = NULL;

    PPDHI_WBEM_SERVER_DEF   pThisServer = NULL;
    IWbemClassObject    *pThisClass = NULL;

    DBG_UNREFERENCED_PARAMETER (LangId);

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

     // allocate a temporary work buffer
    pLocalCounterPath = (PPDHI_COUNTER_PATH) G_ALLOC(
            sizeof(PDHI_COUNTER_PATH) + sizeof(WCHAR) * 2 *
                (  lstrlenW(szStaticLocalMachineName)
                 + lstrlenW(szFullPathBuffer) + 3));

    if (pLocalCounterPath != NULL) {
        dwSize = (DWORD)G_SIZE (pLocalCounterPath);
        assert (dwSize != NULL);

        if (pdhStatus == ERROR_SUCCESS) {
            // get WBEM server since we'll probably need it later
            if (ParseFullPathNameW (szFullPathBuffer,
                &dwSize, pLocalCounterPath,
                (dwFlags & PDH_PATH_WBEM_INPUT ? TRUE : FALSE))) {
                // parsed successfully so load into user's buffer
                if (*pdwBufferSize != 0) {
                    if (pCounterPathElements != NULL) {
                        // see if there's enough room
                        if (*pdwBufferSize >= dwSize) {
                            // there's room so copy / translate the data
                            szString = (LPWSTR)&pCounterPathElements[1];
                            if (pLocalCounterPath->szMachineName != NULL) {
                                pCounterPathElements->szMachineName = szString;
                                lstrcpyW (szString, pLocalCounterPath->szMachineName);
                                szString += lstrlenW (szString) + 1;
                                szString = (LPWSTR)ALIGN_ON_DWORD (szString);
                            } else {
                                pCounterPathElements->szMachineName = NULL;
                            }
                            dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);
                        }

                        // Now that we have the proper machine name,
                        // connect to the server if we need to
                        if (dwFlags != (PDH_PATH_WBEM_INPUT | PDH_PATH_WBEM_RESULT)) {
                            pdhStatus = PdhiConnectWbemServer (
                                pCounterPathElements->szMachineName, &pThisServer);
                        } else {
                            // this will just be a copy operation
                            pdhStatus = ERROR_SUCCESS;
                        }

                        if ( pdhStatus == ERROR_SUCCESS ) {

                            if (pLocalCounterPath->szObjectName != NULL) {
                                pCounterPathElements->szObjectName = szString;
                                if (dwFlags & PDH_PATH_WBEM_RESULT) {
                                    if (dwFlags & PDH_PATH_WBEM_INPUT) {
                                        // just copy
                                        szSrc = pLocalCounterPath->szObjectName;
                                    } else {
                                        // interpret the display name to a class name
                                        pdhStatus = PdhiWbemGetObjectClassName (
                                            pThisServer,
                                            pLocalCounterPath->szObjectName,
                                            wszTempBuffer,
                                            sizeof(wszTempBuffer) / sizeof(wszTempBuffer[0]),
                                            &pThisClass);
                                        if (pdhStatus == ERROR_SUCCESS) {
                                            szSrc = wszTempBuffer;
                                        } 
                                    }
                                } else {
                                    if (dwFlags & PDH_PATH_WBEM_INPUT) {
                                        // translate class name to a display name
                                        pdhStatus = PdhiWbemGetClassDisplayName (
                                            pThisServer, pLocalCounterPath->szObjectName,
                                            wszTempBuffer,
                                            sizeof(wszTempBuffer) / sizeof(wszTempBuffer[0]),
                                            &pThisClass);
                                        if (pdhStatus == ERROR_SUCCESS) {
                                            szSrc = wszTempBuffer;
                                        }
                                    } else {
                                        assert (dwFlags != 0); // this should be caught earlier
                                    }
                                }

                                if (pdhStatus == ERROR_SUCCESS) {
                                    dwSize += (lstrlenW(szSrc) +1) * sizeof(WCHAR);
                                    if (*pdwBufferSize >= dwSize) {
                                        lstrcpyW (szString, szSrc);
                                        szString += lstrlenW (szString) + 1;
                                        szString = (LPWSTR)ALIGN_ON_DWORD (szString);
                                        dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);
                                    } else {
                                        // not enough room
                                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                                    }
                                }
                            } else {
                                pCounterPathElements->szObjectName = NULL;
                            }

                            if (pdhStatus == ERROR_SUCCESS) {
                                if (pLocalCounterPath->szInstanceName != NULL) {
                                    pCounterPathElements->szInstanceName = szString;
                                    szSrc = pLocalCounterPath->szInstanceName;
                                    dwSize += (lstrlenW(szSrc) +1) * sizeof(WCHAR);
                                    if (*pdwBufferSize >= dwSize) {
                                        lstrcpyW (szString, szSrc);
                                        szString += lstrlenW (szString) + 1;
                                        szString = (LPWSTR)ALIGN_ON_DWORD (szString);
                                        dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);
                                    } else {
                                        // not enough room
                                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                                    }

                                    if (pLocalCounterPath->szParentName != NULL) {
                                        pCounterPathElements->szParentInstance = szString;
                                        szSrc = pLocalCounterPath->szParentName;
                                        dwSize += (lstrlenW(szSrc) +1) * sizeof(WCHAR);
                                        if (*pdwBufferSize >= dwSize) {
                                            lstrcpyW (szString, szSrc);
                                            szString += lstrlenW (szString) + 1;
                                            szString = (LPWSTR)ALIGN_ON_DWORD (szString);
                                            dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);
                                        } else {
                                            // not enough room
                                            pdhStatus = PDH_INSUFFICIENT_BUFFER;
                                        }
                                    } else {
                                        pCounterPathElements->szParentInstance = NULL;
                                    }

                                    pCounterPathElements->dwInstanceIndex =
                                        pLocalCounterPath->dwIndex;

                                } else {
                                    pCounterPathElements->szInstanceName = NULL;
                                    pCounterPathElements->szParentInstance = NULL;
                                    pCounterPathElements->dwInstanceIndex = (DWORD)-1;
                                }
                            }

                            if (pdhStatus == ERROR_SUCCESS) {
                                if (pLocalCounterPath->szCounterName != NULL) {
                                    pCounterPathElements->szCounterName = szString;
                                    if (dwFlags & PDH_PATH_WBEM_RESULT) {
                                        if (dwFlags & PDH_PATH_WBEM_INPUT) {
                                            // just copy
                                            szSrc = pLocalCounterPath->szCounterName;
                                        } else {
                                            // interpret the display name to a property name
                                            pdhStatus = PdhiWbemGetCounterPropertyName (
                                                pThisClass,
                                                pLocalCounterPath->szCounterName,
                                                wszTempBuffer,
                                                sizeof(wszTempBuffer) / sizeof(wszTempBuffer[0]));
                                            if (pdhStatus == ERROR_SUCCESS) {
                                                szSrc = wszTempBuffer;
                                            }
                                        }
                                    } else {
                                        if (dwFlags & PDH_PATH_WBEM_INPUT) {
                                            // translate class name to a display name
                                            pdhStatus = PdhiWbemGetCounterDisplayName (
                                                pThisClass, pLocalCounterPath->szCounterName,
                                                wszTempBuffer,
                                                sizeof(wszTempBuffer) / sizeof(wszTempBuffer[0]));
                                            if (pdhStatus == ERROR_SUCCESS) {
                                                szSrc = wszTempBuffer;
                                            }
                                        } else {
                                            assert (dwFlags != 0); // this should be caught earlier
                                        }
                                    }
                                    dwSize += (lstrlenW(szSrc) +1) * sizeof(WCHAR);
                                    if (*pdwBufferSize >= dwSize) {
                                        lstrcpyW (szString, szSrc);
                                        szString += lstrlenW (szString) + 1;
                                        szString = (LPWSTR)ALIGN_ON_DWORD (szString);
                                        dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);
                                    } else {
                                        // not enough room
                                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                                    }
                                } else {
                                    pCounterPathElements->szCounterName = NULL;
                                }
                            }
                        }   // If pdhStatus == ERROR_SUCCESS

                        if (pdhStatus == ERROR_SUCCESS) {
                            dwSize = (DWORD)((LPBYTE)szString - (LPBYTE)pCounterPathElements);

                            *pdwBufferSize = dwSize;
                        }
                    } else {
                        // a null buffer pointer was passed int
                        pdhStatus = PDH_INVALID_ARGUMENT;
                    }
                } else {
                    // this is just a size check so return size required
                    *pdwBufferSize = dwSize * 2; // doubled to insure room for path expansions
                    pdhStatus = ERROR_SUCCESS;
                }
            } else {
                // unable to read path
                pdhStatus = PDH_INVALID_PATH;
            }
            // release class object if used
            //if (pThisClass != NULL) pThisClass->Release();

            // Cleanup pThisServer if used
            if ( NULL != pThisServer )
            {
                if (pdhStatus == ERROR_SUCCESS) {
                    pdhStatus = PdhiDisconnectWbemServer (pThisServer);
                } else {
                    // don't trash the return status
                    PdhiDisconnectWbemServer (pThisServer);
                }
            }

        }
        G_FREE (pLocalCounterPath);
    } else {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    return pdhStatus;
}

PDH_FUNCTION
PdhiDecodeWbemPathA (
    IN      LPCSTR                      szFullPathBuffer,
    IN      PDH_COUNTER_PATH_ELEMENTS_A *pCounterPathElements,
    IN      LPDWORD                     pdwBufferSize,
    IN      LANGID                      LangId,
    IN      DWORD                       dwFlags
)
{
    PDH_STATUS  pdhStatus = ERROR_SUCCESS;
    LPWSTR      wszWidePath = NULL;
    PDH_COUNTER_PATH_ELEMENTS_W     *pWideElements = NULL;
    DWORD       dwSize;
    DWORD       dwDest = 0;
    LONG        lSizeRemaining;
    LPSTR       szNextString;

    wszWidePath = (LPWSTR)G_ALLOC((lstrlenA(szFullPathBuffer) + 1) * sizeof(WCHAR));

    if (wszWidePath == NULL) {
        pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // compute size of temp element buffer
        lSizeRemaining = * pdwBufferSize - sizeof(PDH_COUNTER_PATH_ELEMENTS_A);
        dwSize = * pdwBufferSize - sizeof(PDH_COUNTER_PATH_ELEMENTS_A);
        // dwSize now has the size of the buffer AFTER the structure so
        // adjust this for the longer char length to make it a fair comparison
        dwSize *= sizeof(WCHAR)/sizeof(CHAR);
        // and add back in the structure
        dwSize += sizeof(PDH_COUNTER_PATH_ELEMENTS_W);

        if (pCounterPathElements != NULL) {
            pWideElements = (PDH_COUNTER_PATH_ELEMENTS_W *) G_ALLOC(dwSize);
            if (pWideElements == NULL) {
                pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            }
        } else {
            pWideElements = NULL;
            pdhStatus = ERROR_SUCCESS;
        }
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // convert path to Wide
        MultiByteToWideChar(_getmbcp(),
                    0,
                    szFullPathBuffer,
                    lstrlenA(szFullPathBuffer),
                    wszWidePath,
                    lstrlenA(szFullPathBuffer) + 1);
        pdhStatus = PdhiDecodeWbemPathW (
                    wszWidePath,
                    pWideElements,
                    & dwSize,
                    LangId,
                    dwFlags);

        if (pdhStatus == ERROR_SUCCESS) {
            if (pCounterPathElements != NULL) {
                // populate the fields of the caller's buffer
                szNextString = (LPSTR)&pCounterPathElements[1];

                if (   pWideElements->szMachineName != NULL
                    && lSizeRemaining > 0) {
                    dwDest    = lSizeRemaining;
                    pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                pWideElements->szMachineName,
                                szNextString,
                                & dwDest);
                    if (pdhStatus == ERROR_SUCCESS) {
                        pCounterPathElements->szMachineName = szNextString;
                        szNextString += dwDest + 1;
                    }
                    else {
                        pCounterPathElements->szMachineName = NULL;
                    }
                    lSizeRemaining -= dwDest + 1;
                } else {
                    pCounterPathElements->szMachineName = NULL;
                }

                if (   pWideElements->szObjectName != NULL
                    && lSizeRemaining > 0) {
                    dwDest    = lSizeRemaining;
                    pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                pWideElements->szObjectName,
                                szNextString,
                                & dwDest);
                    if (pdhStatus == ERROR_SUCCESS) {
                        pCounterPathElements->szObjectName = szNextString;
                        szNextString += dwDest + 1;
                    }
                    else {
                        pCounterPathElements->szObjectName = NULL;
                    }
                    lSizeRemaining -= dwDest + 1;
                } else {
                    pCounterPathElements->szObjectName = NULL;
                }

                if (   pWideElements->szInstanceName != NULL
                    && lSizeRemaining > 0) {
                    dwDest    = lSizeRemaining;
                    pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                pWideElements->szInstanceName,
                                szNextString,
                                & dwDest);
                    if (pdhStatus == ERROR_SUCCESS) {
                        pCounterPathElements->szInstanceName = szNextString;
                        szNextString += dwDest + 1;
                    }
                    else {
                        pCounterPathElements->szInstanceName = NULL;
                    }
                    lSizeRemaining -= dwDest + 1;
                } else {
                    pCounterPathElements->szInstanceName = NULL;
                }

                if (   pWideElements->szParentInstance != NULL
                    && lSizeRemaining > 0) {
                    dwDest    = lSizeRemaining;
                    pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                pWideElements->szParentInstance,
                                szNextString,
                                & dwDest);
                    if (pdhStatus == ERROR_SUCCESS) {
                        pCounterPathElements->szParentInstance = szNextString;
                        szNextString += dwDest + 1;
                    }
                    else {
                        pCounterPathElements->szParentInstance = NULL;
                    }
                    lSizeRemaining -= dwDest + 1;
                } else {
                    pCounterPathElements->szParentInstance = NULL;
                }

                if (   pWideElements->szCounterName != NULL
                    && lSizeRemaining > 0) {
                    dwDest    = lSizeRemaining;
                    pdhStatus = PdhiConvertUnicodeToAnsi(_getmbcp(),
                                pWideElements->szObjectName,
                                szNextString,
                                & dwDest);
                    if (pdhStatus == ERROR_SUCCESS) {
                        pCounterPathElements->szCounterName = szNextString;
                        szNextString   += dwDest + 1;
                    }
                    else {
                        pCounterPathElements->szCounterName = NULL;
                    }
                    lSizeRemaining -= dwDest + 1;
                } else {
                    pCounterPathElements->szCounterName = NULL;
                }

                pCounterPathElements->dwInstanceIndex =
                    pWideElements->dwInstanceIndex;

                *pdwBufferSize = (DWORD)((LPBYTE)szNextString - (LPBYTE)pCounterPathElements);
            } else {
                // just return the size required adjusted for wide/ansi characters
                *pdwBufferSize = sizeof(PDH_COUNTER_PATH_ELEMENTS_A);
                dwSize -= sizeof(PDH_COUNTER_PATH_ELEMENTS_W);
                dwSize /= sizeof(WCHAR)/sizeof(CHAR);
                *pdwBufferSize += dwSize;
            }
        } else {
            // call to wide function failed so just return error
        }
    } else {
        // memory allocation failed so return error
    }

    if (pWideElements != NULL) G_FREE(pWideElements);
    if (wszWidePath != NULL) G_FREE(wszWidePath);

    return pdhStatus;
}

BOOL
WbemInitCounter (
    IN      PPDHI_COUNTER pCounter
)
/*++

Routine Description:

    Initialized the counter data structure by:
        Allocating the memory block to contain the counter structure
            and all the associated data fields. If this allocation
            is successful, then the fields are initialized by
            verifying the counter is valid.

Arguments:

    IN      PPDHI_COUNTER pCounter
        pointer of the counter to initialize using the system data

Return Value:

    TRUE if the counter was successfully initialized
    FALSE if a problem was encountered

    In either case, the CStatus field of the structure is updated to
    indicate the status of the operation.

--*/
{
    DWORD               dwResult;
    PDH_STATUS          pdhStatus = ERROR_SUCCESS;
    PPDHI_WBEM_SERVER_DEF   pWbemServer = NULL;
    DWORD               dwLastError = ERROR_SUCCESS;
    HRESULT             hRes = S_OK;
    VARIANT             vCountertype;
    WCHAR               szBasePropertyName[MAX_PATH];
    WCHAR               szFreqPropertyName[MAX_PATH];
    WCHAR               szWbemItemPath[MAX_PATH];
    ULONGLONG           llValue;
    LONG                lOffset;

    PPDH_COUNTER_PATH_ELEMENTS_W    pPathElem = NULL;
    BOOL                            bReturn = TRUE;
    DWORD                           dwBufferSize = 0;
    BSTR                            bsPropName = NULL;
    BSTR                            bsCountertype = NULL;
    IWbemQualifierSet               *pQualSet = NULL;
    PPDHI_COUNTER                   pCounterInList = NULL;
    PPDHI_COUNTER_PATH              pPdhiCtrPath = NULL;
    BOOL                bMatchFound;
    DWORD               bDisconnectServer = FALSE;

    // CoInitialize() if we need to
    BOOL    fCoInitialized = PdhiCoInitialize();

    VariantInit (&vCountertype);

    pCounter->dwFlags |= PDHIC_WBEM_COUNTER; // make sure WBEM flag is set

    // make sure the query has a refresher started already
    if (pCounter->pOwner->pRefresher == NULL) {
        // it hasn't been started so start now
        dwResult = CoCreateRefresher( &pCounter->pOwner->pRefresher );
        if ((dwResult != S_OK) || (pCounter->pOwner->pRefresher ==  NULL)) {
            pCounter->pOwner->pRefresher = NULL;
            dwLastError = PDH_WBEM_ERROR;
            bReturn = FALSE;
        } else {
            // open config interface
            dwResult = pCounter->pOwner->pRefresher->QueryInterface (
                IID_IWbemConfigureRefresher,
                (LPVOID *)&pCounter->pOwner->pRefresherCfg);
            if (dwResult != S_OK) {
                pCounter->pOwner->pRefresherCfg = NULL;
                pCounter->pOwner->pRefresher->Release();
                pCounter->pOwner->pRefresher = NULL;
                dwLastError = PDH_WBEM_ERROR;
                bReturn = FALSE;
            }
        }
    }

    if (bReturn) {
        // so far so good, now figure out the WBEM path to add it to the
        // refresher
        dwBufferSize = lstrlenW(pCounter->szFullName) * sizeof(WCHAR) * 10;
        dwBufferSize += sizeof (PDH_COUNTER_PATH_ELEMENTS_W);

        pPathElem = (PPDH_COUNTER_PATH_ELEMENTS_W) G_ALLOC (dwBufferSize);
        // the path is display names, so convert to WBEM class names first

        if (pPathElem == NULL) {
            dwLastError = PDH_MEMORY_ALLOCATION_FAILURE;
            bReturn = FALSE;
        } else {
            pdhStatus = PdhiDecodeWbemPathW (
                pCounter->szFullName,
                pPathElem,
                &dwBufferSize,
                pCounter->pOwner->LangID,
                PDH_PATH_WBEM_RESULT);
            if (pdhStatus == ERROR_SUCCESS) {
                // continue
            } else {
                dwLastError = PDH_INVALID_PATH;
                bReturn = FALSE;
            }
        }
    }

    if (bReturn) {
        dwBufferSize *= 8; // just to be safe
        pPdhiCtrPath = (PPDHI_COUNTER_PATH) G_ALLOC (dwBufferSize);
        if (pPdhiCtrPath == NULL) {
            dwLastError = PDH_MEMORY_ALLOCATION_FAILURE;
            bReturn = FALSE;
        } else {
            // break path into display elements
            bReturn = ParseFullPathNameW (
                pCounter->szFullName,
                &dwBufferSize,
                pPdhiCtrPath,
                FALSE);
            if (bReturn) {
                // realloc to use only the memory needed
                pCounter->pCounterPath = (PPDHI_COUNTER_PATH)
                    G_REALLOC (pPdhiCtrPath, dwBufferSize);
                if ((pPdhiCtrPath != pCounter->pCounterPath) &&
                    (pCounter->pCounterPath != NULL)){
                    // the memory block moved so
                    // correct addresses inside structure
                    lOffset = (LONG)((ULONG_PTR)pCounter->pCounterPath -
                                     (ULONG_PTR)pPdhiCtrPath);
                    if (pCounter->pCounterPath->szMachineName) {
                        pCounter->pCounterPath->szMachineName = (LPWSTR)(
                            (LPBYTE)pCounter->pCounterPath->szMachineName + lOffset);
                    }
                    if (pCounter->pCounterPath->szObjectName) {
                        pCounter->pCounterPath->szObjectName = (LPWSTR)(
                            (LPBYTE)pCounter->pCounterPath->szObjectName + lOffset);
                    }
                    if (pCounter->pCounterPath->szInstanceName) {
                        pCounter->pCounterPath->szInstanceName = (LPWSTR)(
                            (LPBYTE)pCounter->pCounterPath->szInstanceName + lOffset);
                    }
                    if (pCounter->pCounterPath->szParentName) {
                        pCounter->pCounterPath->szParentName = (LPWSTR)(
                            (LPBYTE)pCounter->pCounterPath->szParentName + lOffset);
                    }
                    if (pCounter->pCounterPath->szCounterName) {
                        pCounter->pCounterPath->szCounterName = (LPWSTR)(
                            (LPBYTE)pCounter->pCounterPath->szCounterName + lOffset);
                    }
                }
            } else {
                // free the buffer
                G_FREE (pPdhiCtrPath);
                dwLastError = PDH_WBEM_ERROR;
            }
        }
    }

    // connect to the WBEM Server on that machine
    if (bReturn) {
        pdhStatus = PdhiConnectWbemServer (
            pCounter->pCounterPath->szMachineName,
            &pWbemServer);
        if (pdhStatus != ERROR_SUCCESS) {
            dwLastError = pdhStatus;
            bReturn = FALSE;
        } else {
            bDisconnectServer = TRUE;
        }
    }

    if (bReturn) {
        // make WBEM Instance path out of path elements
        pdhStatus = PdhiMakeWbemInstancePath (
            pPathElem,
            szWbemItemPath,
            TRUE);

        // check for an object/class of this type that has already been added
        // walk down counter list to find a matching:
        //  machine\namespace
        //  object
        //  instance name
        if (pdhStatus != ERROR_SUCCESS) {
            dwLastError = pdhStatus;
            bReturn = FALSE;
        }
    }

    if (bReturn) {
        assert (pCounter->pWbemObject == NULL);
        assert (pCounter->lWbemRefreshId == 0);

        pCounterInList = pCounter->pOwner->pCounterListHead;
        if (pCounterInList == NULL) {
            // then there are no entries to search so continue
        } else {
            do {
                // check for matching machine name
                bMatchFound = FALSE;
                if (lstrcmpiW(pCounterInList->pCounterPath->szMachineName,
                    pCounter->pCounterPath->szMachineName) == 0) {
                    // then the machine name matches
                    if (lstrcmpiW (pCounterInList->pCounterPath->szObjectName,
                        pCounter->pCounterPath->szObjectName) == 0) {
                        // then the object name matches
                        // see if the instance matches
                        if (lstrcmpiW (pCounterInList->pCounterPath->szInstanceName,
                            pCounter->pCounterPath->szInstanceName) == 0) {
                            if (pCounter->pCounterPath->szParentName != 0) {
                                if (lstrcmpiW (pCounterInList->pCounterPath->szParentName,
                                    pCounter->pCounterPath->szParentName) == 0) {
                                    // then this is a match
                                    bMatchFound = TRUE;
                                } else {
                                    // not a match
                                }
                            } else {
                                // this is a match
                                bMatchFound = TRUE;
                            }

                            if (bMatchFound) {
                                if ((pCounter->pCounterPath->szInstanceName != NULL) &&
                                    (*pCounter->pCounterPath->szInstanceName == SPLAT_L)) {
                                    // then this is a Wild Card or multiple instance path
                                    // see if an enumerator for this object has already been created
                                    // if so, then AddRef it
                                    if (pCounterInList->pWbemEnum != NULL) {
                                        pCounter->pWbemObject = pCounterInList->pWbemObject;
                                        pCounter->pWbemEnum = pCounterInList->pWbemEnum;
                                        // bump the ref counts on this object so it
                                        //  doesn't disapper from us
                                        pCounter->pWbemObject->AddRef();
                                        pCounter->pWbemEnum->AddRef();
                                        pCounter->lWbemEnumId = pCounterInList->lWbemEnumId;
                                        pCounter->dwFlags |= PDHIC_MULTI_INSTANCE;
                                    }
                                    // and exit loop
                                    hRes = S_OK;
                                    break;
                                } else {
                                    // then it's a regular instance the instance name matches
                                    // so get the Object pointer
                                    pCounter->pWbemObject = pCounterInList->pWbemObject;
                                    pCounter->pWbemAccess = pCounterInList->pWbemAccess;
                                    // bump the ref counts on this object so it
                                    //  doesn't disapper from us
                                    pCounter->pWbemObject->AddRef();
                                    pCounter->pWbemAccess->AddRef();
                                    pCounter->lWbemRefreshId = pCounterInList->lWbemRefreshId;
                                    // and exit loop
                                    hRes = S_OK;
                                    break;
                                }
                            } else {
                                // no match so go to next one
                            }
                        } else {
                            // no match so go to next one
                        }
                    } else {
                        // no match so go to next one
                    }
                } else {
                    // no match so go to next counter
                }
                pCounterInList = pCounterInList->next.flink;
            } while (pCounterInList != pCounter->pOwner->pCounterListHead);
        }

        bDontRefresh = TRUE;

        // determine if we should and an object or an enumerator
        if ((pCounter->pCounterPath->szInstanceName != NULL) &&
            (*pCounter->pCounterPath->szInstanceName == SPLAT_L)) {
            // then this is an enum type so see if there's already one assigned
            // if not, then create one
            if (pCounter->pWbemEnum == NULL) {
                if (pCounter->pOwner->pRefresherCfg != NULL) {
                    hRes = pCounter->pOwner->pRefresherCfg->AddEnum(
                        pWbemServer->pSvc,
                        pPathElem->szObjectName,
                        WBEM_FLAG_USE_AMENDED_QUALIFIERS, 0,
                        &pCounter->pWbemEnum,
                        &pCounter->lWbemEnumId);
                } else {
                    hRes = WBEM_E_INITIALIZATION_FAILURE;
                }

                if (hRes != S_OK) {
                    bReturn = FALSE;
                    dwLastError = PDH_WBEM_ERROR;
                } else {
                    pdhStatus = PdhiWbemGetClassObjectByName (
                        pWbemServer,
                        pPathElem->szObjectName,
                        &pCounter->pWbemObject);
                }
                // set multi instance flag
                pCounter->dwFlags |= PDHIC_MULTI_INSTANCE;
            } else {
                // we must have copied another one so continue
            }

        } else {
            // this is a single counter
            if (pCounter->pWbemObject == NULL) {
                // and it hasn't been added yet, so just add one object
                if (pCounter->pOwner->pRefresherCfg != NULL) {
                    hRes = pCounter->pOwner->pRefresherCfg->AddObjectByPath (
                        pWbemServer->pSvc,
                        szWbemItemPath,
                        WBEM_FLAG_USE_AMENDED_QUALIFIERS, 0,
                        &pCounter->pWbemObject,
                        &pCounter->lWbemRefreshId);
                } else {
                    hRes = WBEM_E_INITIALIZATION_FAILURE;
                }

                if (hRes != S_OK) {
                    bReturn = FALSE;
                    dwLastError = PDH_WBEM_ERROR;
                }
            } else {
                // it must have been copied from another
            }
        }

        if (hRes == S_OK) {
            // get handles for subsequent data collection from this object
            hRes = pCounter->pWbemObject->QueryInterface (IID_IWbemObjectAccess,
                (LPVOID *)&pCounter->pWbemAccess);
            if (hRes == S_OK) {
                if (!PdhiIsSingletonClass (pCounter->pWbemObject)) {
                    CIMTYPE cimType = 0;
                    bsPropName = SysAllocString(cszName);
                    if (bsPropName) {
                        // get handle to the name property for this counter
                        hRes = pCounter->pWbemAccess->GetPropertyHandle (
                            bsPropName, &cimType,
                            &pCounter->lNameHandle);
                        if (hRes != S_OK) {
                            dwLastError = PDH_WBEM_ERROR;
                        }
                        assert (cimType == CIM_STRING);
                    } else {
                        dwLastError = PDH_MEMORY_ALLOCATION_FAILURE;
                        hRes = WBEM_E_OUT_OF_MEMORY;
                    }
                } else {
                    pCounter->lNameHandle = -1;
                }
                if (hRes == S_OK) {
                    // get handle to the data property for this counter
                    hRes = pCounter->pWbemAccess->GetPropertyHandle (
                        pPathElem->szCounterName, &pCounter->lNumItemType,
                        &pCounter->lNumItemHandle);
                    assert (hRes == S_OK);

                    // get counter type field
                    // first get the property qualifiers
                    PdhiSysFreeString (&bsPropName);
                    bsPropName = SysAllocString (pPathElem->szCounterName);
                    if (bsPropName) {
                        hRes = pCounter->pWbemObject->GetPropertyQualifierSet (
                            bsPropName, &pQualSet);
                    } else {
                        hRes = WBEM_E_OUT_OF_MEMORY;
                    }

                    if (hRes == WBEM_NO_ERROR) {
                        // now get the specific value
                        VariantClear (&vCountertype);
                        bsCountertype = SysAllocString (cszCountertype);
                        if (bsCountertype) {
                            hRes = pQualSet->Get (bsCountertype, 0, &vCountertype, NULL);
                            if (hRes == WBEM_NO_ERROR) {
                                pCounter->plCounterInfo.dwCounterType = (DWORD)V_I4(&vCountertype);
                            } else {
                                pCounter->plCounterInfo.dwCounterType = 0;
                            }
                            PdhiSysFreeString (&bsCountertype);
                        } else {
                            hRes = WBEM_E_OUT_OF_MEMORY;
                        }


                        if (hRes == WBEM_NO_ERROR) {
 
                            // if this is a fraction counter that has a "base" value
                            // then look it up by appending the "base" string to the
                            // property name

                            if ((pCounter->plCounterInfo.dwCounterType == PERF_SAMPLE_FRACTION) ||
                                (pCounter->plCounterInfo.dwCounterType == PERF_AVERAGE_TIMER)   ||
                                (pCounter->plCounterInfo.dwCounterType == PERF_AVERAGE_BULK)    ||
                                (pCounter->plCounterInfo.dwCounterType == PERF_LARGE_RAW_FRACTION) ||
                                (pCounter->plCounterInfo.dwCounterType == PERF_RAW_FRACTION)) {

                                // make sure we have room for the "_Base" string
                                assert (lstrlenW(pPathElem->szCounterName) < (MAX_PATH - 6));
                                lstrcpyW (szBasePropertyName, pPathElem->szCounterName);
                                lstrcatW (szBasePropertyName, cszBaseSuffix);

                                // get the handle to the denominator
                                hRes = pCounter->pWbemAccess->GetPropertyHandle (
                                    szBasePropertyName, &pCounter->lDenItemType,
                                    &pCounter->lDenItemHandle);
                                assert (hRes == S_OK);

                            } else {
                                // the denominator is a time field
                                if ((pCounter->plCounterInfo.dwCounterType & PERF_TIMER_FIELD) == PERF_TIMER_TICK) {
                                    // use the system perf time timestamp as the denominator
                                    lstrcpyW (szBasePropertyName, cszTimestampPerfTime);
                                    lstrcpyW (szFreqPropertyName, cszFrequencyPerfTime);
                                } else if ((pCounter->plCounterInfo.dwCounterType & PERF_TIMER_FIELD) == PERF_TIMER_100NS) {
                                    lstrcpyW (szBasePropertyName, cszTimestampSys100Ns);
                                    lstrcpyW (szFreqPropertyName, cszFrequencySys100Ns);
                                } else if ((pCounter->plCounterInfo.dwCounterType & PERF_TIMER_FIELD) == PERF_OBJECT_TIMER) {
                                    lstrcpyW (szBasePropertyName, cszTimestampObject);
                                    lstrcpyW (szFreqPropertyName, cszFrequencyObject);
                                } else {
                                    assert (FALSE); // this should never happen
                                }

                                // get the handle to the denominator
                                hRes = pCounter->pWbemAccess->GetPropertyHandle (
                                    szBasePropertyName, &pCounter->lDenItemType,
                                    &pCounter->lDenItemHandle);
                                assert (hRes == S_OK);

                                // get the handle to the frequency
                                hRes = pCounter->pWbemAccess->GetPropertyHandle (
                                    szFreqPropertyName, &pCounter->lFreqItemType,
                                    &pCounter->lFreqItemHandle);
                                assert (hRes == S_OK);
                            }

                            // get the default scale value of this counter
                            VariantClear (&vCountertype);
                            PdhiSysFreeString (&bsCountertype);
                            bsCountertype = SysAllocString (cszDefaultscale);
                            if (bsCountertype) {
                                hRes = pQualSet->Get (bsCountertype, 0, &vCountertype, NULL);
                                if (hRes == WBEM_NO_ERROR) {
                                    pCounter->lScale = 0;
                                    pCounter->plCounterInfo.lDefaultScale = (DWORD)V_I4(&vCountertype);
                                } else {
                                    pCounter->plCounterInfo.lDefaultScale = 0;
                                    pCounter->lScale = 0;
                                }

                                // this may not be initialized but we try anyway
                                if ((pCounter->lFreqItemType == VT_I8) ||
                                    (pCounter->lFreqItemType == VT_UI8)) {
                                    pCounter->pWbemAccess->ReadQWORD (
                                        pCounter->lFreqItemHandle, &llValue);
                                } else {
                                    llValue = 0;
                                }
                                // the timebase is a 64 bit integer
                                pCounter->TimeBase = llValue;
                            } else {
                                hRes = WBEM_E_OUT_OF_MEMORY;
                            }
                        }
                        PdhiSysFreeString (&bsCountertype);
                        pQualSet->Release();
                    } else {
                        if (hRes == WBEM_E_OUT_OF_MEMORY) {
                            dwLastError = PDH_MEMORY_ALLOCATION_FAILURE;
                        } else {
                            dwLastError = PDH_WBEM_ERROR;
                        }
                        bReturn = FALSE;
                    }
                } // else an error has ocurred
                PdhiSysFreeString (&bsPropName);
            } else {
                dwLastError = PDH_WBEM_ERROR;
                bReturn = FALSE;
            }
        } else {
            dwLastError = PDH_WBEM_ERROR;
            bReturn = FALSE;
        }

        if (bReturn) {
            // clear the not init'd flag to say it's ok to use now
            pCounter->dwFlags &= ~PDHIC_COUNTER_NOT_INIT;
        }

        bDontRefresh = FALSE;
    }

    if (bReturn) {
        if (!AssignCalcFunction (
            pCounter->plCounterInfo.dwCounterType,
            &pCounter->CalcFunc,
            &pCounter->StatFunc)) {
            dwLastError = PDH_FUNCTION_NOT_FOUND;
            bReturn = FALSE;
        }
    }

    if (pPathElem != NULL) G_FREE(pPathElem);
    VariantClear (&vCountertype);

    if (bDisconnectServer) {
        if (pdhStatus == ERROR_SUCCESS) {
            pdhStatus = PdhiDisconnectWbemServer (pWbemServer);
        } else {
            // keep error code from function body
            PdhiDisconnectWbemServer (pWbemServer);
        }
    }

    if (!bReturn) SetLastError (dwLastError);

    // CoUninitialize if necessary
    if ( fCoInitialized )
    {
        PdhiCoUninitialize();
    }

    return bReturn;
}

BOOL
UpdateWbemCounterValue (
    IN      PPDHI_COUNTER   pCounter,
    IN      FILETIME        *pTimeStamp
)
{
    DWORD   LocalCStatus = 0;
    DWORD   LocalCType  = 0;
    ULONGLONG   llValue;
    DWORD       dwValue;

    BOOL    bReturn  = FALSE;

    // move current value to last value buffer
    pCounter->LastValue = pCounter->ThisValue;

    // and clear the old value
    pCounter->ThisValue.MultiCount = 1;
    pCounter->ThisValue.FirstValue =
        pCounter->ThisValue.SecondValue = 0;
    pCounter->ThisValue.TimeStamp = *pTimeStamp;

    // get the counter's machine status first. There's no point in
    // contuning if the machine is offline

    // UpdateWbemCounterValue() will be called only if WBEM refresher succeeds
    // in GetQueryWbemData(); that is, all remote machines should be on-line

    LocalCStatus = ERROR_SUCCESS;

    if (IsSuccessSeverity(LocalCStatus)) {
        // get the pointer to the counter data
        LocalCType = pCounter->plCounterInfo.dwCounterType;
        switch (LocalCType) {
            //
            // these counter types are loaded as:
            //      Numerator = Counter data from perf data block
            //      Denominator = Perf Time from perf data block
            //      (the time base is the PerfFreq)
            //
            case PERF_COUNTER_COUNTER:
            case PERF_COUNTER_QUEUELEN_TYPE:
            case PERF_SAMPLE_COUNTER:
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I4) ||
                        (pCounter->lNumItemType == VT_UI4));
                pCounter->pWbemAccess->ReadDWORD (
                    pCounter->lNumItemHandle, &dwValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)(dwValue);

                assert ((pCounter->lDenItemType == VT_I8) ||
                        (pCounter->lDenItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lDenItemHandle, &llValue);
                // the denominator should be a 64-bit timestamp
                pCounter->ThisValue.SecondValue = llValue;

                // look up the timebase freq if necessary
                if (pCounter->TimeBase == 0) {
                    assert ((pCounter->lFreqItemType == VT_I8) ||
                            (pCounter->lFreqItemType == VT_UI8));
                    pCounter->pWbemAccess->ReadQWORD (
                        pCounter->lFreqItemHandle, &llValue);
                    // the timebase is a 64 bit integer
                    pCounter->TimeBase = llValue;
                }

                break;

            case PERF_ELAPSED_TIME:
            case PERF_100NSEC_TIMER:
            case PERF_100NSEC_TIMER_INV:
            case PERF_COUNTER_TIMER:
            case PERF_COUNTER_TIMER_INV:
            case PERF_COUNTER_BULK_COUNT:
            case PERF_COUNTER_MULTI_TIMER:
            case PERF_COUNTER_MULTI_TIMER_INV:
            case PERF_COUNTER_LARGE_QUEUELEN_TYPE:
            case PERF_OBJ_TIME_TIMER:
            case PERF_COUNTER_100NS_QUEUELEN_TYPE:
            case PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE:
            case PERF_PRECISION_SYSTEM_TIMER:
            case PERF_PRECISION_100NS_TIMER:
            case PERF_PRECISION_OBJECT_TIMER:
                // this should be a QWORD counter
                assert ((pCounter->lNumItemType == VT_I8) ||
                        (pCounter->lNumItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lNumItemHandle, &llValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)(llValue);

                assert ((pCounter->lDenItemType == VT_I8) ||
                        (pCounter->lDenItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lDenItemHandle, &llValue);
                // the denominator should be a 64-bit timestamp
                pCounter->ThisValue.SecondValue = llValue;

                // look up the timebase freq if necessary
                if (pCounter->TimeBase == 0) {
                    assert ((pCounter->lFreqItemType == VT_I8) ||
                            (pCounter->lFreqItemType == VT_UI8));
                    pCounter->pWbemAccess->ReadQWORD (
                        pCounter->lFreqItemHandle, &llValue);
                    // the timebase is a 64 bit integer
                    pCounter->TimeBase = llValue;
                }

                break;
            //
            //  These counters do not use any time reference
            //
            case PERF_COUNTER_RAWCOUNT:
            case PERF_COUNTER_RAWCOUNT_HEX:
            case PERF_COUNTER_DELTA:
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I4) ||
                        (pCounter->lNumItemType == VT_UI4));
                pCounter->pWbemAccess->ReadDWORD (
                    pCounter->lNumItemHandle, &dwValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)(dwValue);
                pCounter->ThisValue.SecondValue = 0;
                break;

            case PERF_COUNTER_LARGE_RAWCOUNT:
            case PERF_COUNTER_LARGE_RAWCOUNT_HEX:
            case PERF_COUNTER_LARGE_DELTA:
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I8) ||
                        (pCounter->lNumItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lNumItemHandle, &llValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)(llValue);
                pCounter->ThisValue.SecondValue = 0;
                break;

            //
            //  These counters use two data points, the one pointed to by
            //  pData and the one immediately after
            //
            case PERF_SAMPLE_FRACTION:
            case PERF_RAW_FRACTION:
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I4) ||
                        (pCounter->lNumItemType == VT_UI4));
                pCounter->pWbemAccess->ReadDWORD (
                    pCounter->lNumItemHandle, &dwValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)dwValue;

                assert ((pCounter->lDenItemType == VT_I4) ||
                        (pCounter->lDenItemType == VT_UI4));
                pCounter->pWbemAccess->ReadDWORD (
                    pCounter->lDenItemHandle, &dwValue);
                // the denominator should be a 32-bit value
                pCounter->ThisValue.SecondValue = (LONGLONG)dwValue;
                break;

            case PERF_LARGE_RAW_FRACTION:
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I8) ||
                        (pCounter->lNumItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lNumItemHandle, & llValue);
                pCounter->ThisValue.FirstValue = (LONGLONG) llValue;

                assert ((pCounter->lDenItemType == VT_I8) ||
                        (pCounter->lDenItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lDenItemHandle, & llValue);
                // the denominator should be a 32-bit value
                pCounter->ThisValue.SecondValue = (LONGLONG) llValue;
            break;

            case PERF_AVERAGE_TIMER:
            case PERF_AVERAGE_BULK:
                // counter (numerator) is a LONGLONG, while the
                // denominator is just a DWORD
                // this should be a DWORD counter
                assert ((pCounter->lNumItemType == VT_I8) ||
                        (pCounter->lNumItemType == VT_UI8));
                pCounter->pWbemAccess->ReadQWORD (
                    pCounter->lNumItemHandle, &llValue);
                pCounter->ThisValue.FirstValue = (LONGLONG)llValue;

                assert ((pCounter->lDenItemType == VT_I4) ||
                        (pCounter->lDenItemType == VT_UI4));
                pCounter->pWbemAccess->ReadDWORD (
                    pCounter->lDenItemHandle, &dwValue);
                // the denominator should be a 32-bit value
                pCounter->ThisValue.SecondValue = (LONGLONG)dwValue;

                // look up the timebase freq if necessary
                if (pCounter->TimeBase == 0) {
                    assert ((pCounter->lFreqItemType == VT_I8) ||
                            (pCounter->lFreqItemType == VT_UI8));
                    pCounter->pWbemAccess->ReadQWORD (
                        pCounter->lFreqItemHandle, &llValue);
                    // the timebase is a 64 bit integer
                    pCounter->TimeBase = llValue;
                }
                break;
            //
            //  These counters are used as the part of another counter
            //  and as such should not be used, but in case they are
            //  they'll be handled here.
            //
            case PERF_SAMPLE_BASE:
            case PERF_AVERAGE_BASE:
            case PERF_COUNTER_MULTI_BASE:
            case PERF_RAW_BASE:
            case PERF_LARGE_RAW_BASE:
                pCounter->ThisValue.FirstValue = 0;
                pCounter->ThisValue.SecondValue = 0;
                break;

            //
            //  These counters are not supported by this function (yet)
            //
            case PERF_COUNTER_TEXT:
            case PERF_COUNTER_NODATA:
            case PERF_COUNTER_HISTOGRAM_TYPE:
                pCounter->ThisValue.FirstValue = 0;
                pCounter->ThisValue.SecondValue = 0;
                break;

            case PERF_100NSEC_MULTI_TIMER:
            case PERF_100NSEC_MULTI_TIMER_INV:
            default:
                // an unidentified  or unsupported
                // counter was returned so
                pCounter->ThisValue.FirstValue = 0;
                pCounter->ThisValue.SecondValue = 0;
                bReturn = FALSE;
                break;
        }
    } else {
        // else this counter is not valid so this value == 0
        pCounter->ThisValue.CStatus     = LocalCStatus;
        pCounter->ThisValue.FirstValue  = 0;
        pCounter->ThisValue.SecondValue = 0;
        bReturn = FALSE;
    }

    return bReturn;
}

BOOL
UpdateWbemMultiInstanceCounterValue (
    IN      PPDHI_COUNTER   pCounter,
    IN      FILETIME        *pTimestamp
)
{
    IWbemObjectAccess   *pWbemAccess;
    HRESULT     hRes;

    DWORD       LocalCStatus = 0;
    DWORD       LocalCType  = 0;
    DWORD       dwValue;
    ULONGLONG   llValue;
    DWORD       dwSize;
    DWORD       dwFinalSize;
    LONG        lAvailableSize;
    LONG        lReturnSize;
    LONG        lThisInstanceIndex;
    LONG        lNumInstances;

    LPWSTR  szNextNameString;
    PPDHI_RAW_COUNTER_ITEM   pThisItem;

    BOOL    bReturn  = FALSE;

    if (pCounter->pThisRawItemList != NULL) {
        // free old counter buffer list
        G_FREE(pCounter->pLastRawItemList);
        pCounter->pLastRawItemList =
            pCounter->pThisRawItemList;
        pCounter->pThisRawItemList = NULL;
    }

    // get the counter's machine status first. There's no point in
    // contuning if the machine is offline

    // UpdateWbemCounterValue() will be called only if WBEM refresher succeeds
    // in GetQueryWbemData(); that is, all remote machines should be on-line

    LocalCStatus = ERROR_SUCCESS;

    if (IsSuccessSeverity(LocalCStatus)) {
        IWbemObjectAccess   **pWbemInstances = NULL;
        // get count of instances in enumerator
        assert (pCounter->pWbemEnum != NULL);
        hRes = pCounter->pWbemEnum->GetObjects(0, 0, NULL, (LPDWORD)&lNumInstances);
        if (hRes == WBEM_E_BUFFER_TOO_SMALL) {
            // then we should know how many have been returned so allocate an
            // array of pointers
            pWbemInstances = new IWbemObjectAccess * [lNumInstances];
            assert (pWbemInstances != NULL);
            if (pWbemInstances == NULL) {
                SetLastError(ERROR_OUTOFMEMORY);
                hRes    = ERROR_OUTOFMEMORY;
                bReturn = FALSE;
            }
            else {
                hRes = pCounter->pWbemEnum->GetObjects(0,
                    lNumInstances, pWbemInstances, (LPDWORD)&lNumInstances);
            }

            if (hRes == S_OK && lNumInstances > 0) {
                // then we have a table of instances
                // estimate the size required for the new data block
                dwSize = sizeof (PDHI_RAW_COUNTER_ITEM_BLOCK) - sizeof (PDHI_RAW_COUNTER_ITEM);
                dwSize += lNumInstances * (sizeof(PDH_RAW_COUNTER_ITEM_W) + (MAX_PATH * 2 * sizeof(WCHAR)));

                pCounter->pThisRawItemList = (PPDHI_RAW_COUNTER_ITEM_BLOCK)G_ALLOC (dwSize);

                if (pCounter->pThisRawItemList != NULL) {
                    dwFinalSize = lNumInstances * sizeof(PDH_RAW_COUNTER_ITEM_W);
                    szNextNameString = (LPWSTR)((PBYTE)pCounter->pThisRawItemList + dwFinalSize);

                    for (lThisInstanceIndex = 0;
                        lThisInstanceIndex < lNumInstances;
                        lThisInstanceIndex++) {
                        // get pointer to this raw data block in the array
                        pThisItem = &pCounter->pThisRawItemList->pItemArray[lThisInstanceIndex];
                        // get pointer to this IWbemObjectAccess pointer
                        pWbemAccess = pWbemInstances[lThisInstanceIndex];
                        // compute the remaining size of the buffer
                        lAvailableSize = (long)(dwSize - dwFinalSize);

                        assert (lAvailableSize > 0);

                        if (pCounter->lNameHandle != -1) {
                            hRes = pWbemAccess->ReadPropertyValue(
                                    pCounter->lNameHandle,
                                    lAvailableSize,
                                    &lReturnSize,
                                    (LPBYTE)szNextNameString);
                            assert(hRes == S_OK);
                        } else {
                            szNextNameString[0] = ATSIGN_L;
                            szNextNameString[1] = 0;
                            lReturnSize = 2;
                        }
                        pThisItem->szName = (DWORD)
                                (  ((LPBYTE) szNextNameString)
                                 - ((LPBYTE) pCounter->pThisRawItemList));
                        szNextNameString = (LPWSTR)((LPBYTE)szNextNameString + lReturnSize);
                        dwFinalSize += lReturnSize;
                        dwFinalSize = DWORD_MULTIPLE(dwFinalSize);

                        LocalCType = pCounter->plCounterInfo.dwCounterType;
                        switch (LocalCType) {
                            //
                            // these counter types are loaded as:
                            //      Numerator = Counter data from perf data block
                            //      Denominator = Perf Time from perf data block
                            //      (the time base is the PerfFreq)
                            //
                            case PERF_COUNTER_COUNTER:
                            case PERF_COUNTER_QUEUELEN_TYPE:
                            case PERF_SAMPLE_COUNTER:
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I4) ||
                                        (pCounter->lNumItemType == VT_UI4));
                                pWbemAccess->ReadDWORD (
                                        pCounter->lNumItemHandle, &dwValue);
                                pThisItem->FirstValue = (LONGLONG)(dwValue);

                                assert ((pCounter->lDenItemType == VT_I8) ||
                                        (pCounter->lDenItemType == VT_UI8));
                                pWbemAccess->ReadQWORD (
                                        pCounter->lDenItemHandle, &llValue);
                                // the denominator should be a 64-bit timestamp
                                pThisItem->SecondValue = llValue;

                                // look up the timebase freq if necessary
                                if (pCounter->TimeBase == 0) {
                                    assert ((pCounter->lFreqItemType == VT_I8) ||
                                            (pCounter->lFreqItemType == VT_UI8));
                                    pWbemAccess->ReadQWORD (
                                            pCounter->lFreqItemHandle, &llValue);
                                    // the timebase is a 64 bit integer
                                    pCounter->TimeBase = llValue;
                                }
                                break;

                            case PERF_ELAPSED_TIME:
                            case PERF_100NSEC_TIMER:
                            case PERF_100NSEC_TIMER_INV:
                            case PERF_COUNTER_TIMER:
                            case PERF_COUNTER_TIMER_INV:
                            case PERF_COUNTER_BULK_COUNT:
                            case PERF_COUNTER_MULTI_TIMER:
                            case PERF_COUNTER_MULTI_TIMER_INV:
                            case PERF_COUNTER_LARGE_QUEUELEN_TYPE:
                            case PERF_OBJ_TIME_TIMER:
                            case PERF_COUNTER_100NS_QUEUELEN_TYPE:
                            case PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE:
                            case PERF_PRECISION_SYSTEM_TIMER:
                            case PERF_PRECISION_100NS_TIMER:
                            case PERF_PRECISION_OBJECT_TIMER:
                                // this should be a QWORD counter
                                assert ((pCounter->lNumItemType == VT_I8) ||
                                        (pCounter->lNumItemType == VT_UI8));
                                pWbemAccess->ReadQWORD (
                                        pCounter->lNumItemHandle, &llValue);
                                pThisItem->FirstValue = (LONGLONG)(llValue);

                                assert ((pCounter->lDenItemType == VT_I8) ||
                                        (pCounter->lDenItemType == VT_UI8));
                                pWbemAccess->ReadQWORD (
                                        pCounter->lDenItemHandle, &llValue);
                                // the denominator should be a 64-bit timestamp
                                pThisItem->SecondValue = llValue;

                                // look up the timebase freq if necessary
                                if (pCounter->TimeBase == 0) {
                                    assert ((pCounter->lFreqItemType == VT_I8) ||
                                            (pCounter->lFreqItemType == VT_UI8));
                                    pWbemAccess->ReadQWORD (
                                            pCounter->lFreqItemHandle, &llValue);
                                    // the timebase is a 64 bit integer
                                    pCounter->TimeBase = llValue;
                                }
                                break;
                            //
                            //  These counters do not use any time reference
                            //
                            case PERF_COUNTER_RAWCOUNT:
                            case PERF_COUNTER_RAWCOUNT_HEX:
                            case PERF_COUNTER_DELTA:
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I4) ||
                                        (pCounter->lNumItemType == VT_UI4));
                                pWbemAccess->ReadDWORD (
                                        pCounter->lNumItemHandle, &dwValue);
                                pThisItem->FirstValue = (LONGLONG)(dwValue);
                                pThisItem->SecondValue = 0;
                                break;

                            case PERF_COUNTER_LARGE_RAWCOUNT:
                            case PERF_COUNTER_LARGE_RAWCOUNT_HEX:
                            case PERF_COUNTER_LARGE_DELTA:
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I8) ||
                                        (pCounter->lNumItemType == VT_UI8));
                                pWbemAccess->ReadQWORD (
                                        pCounter->lNumItemHandle, &llValue);
                                pThisItem->FirstValue = (LONGLONG)(llValue);
                                pThisItem->SecondValue = 0;
                                break;

                            //
                            //  These counters use two data points, the one pointed to by
                            //  pData and the one immediately after
                            //
                            case PERF_SAMPLE_FRACTION:
                            case PERF_RAW_FRACTION:
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I4) ||
                                        (pCounter->lNumItemType == VT_UI4));
                                pWbemAccess->ReadDWORD (
                                        pCounter->lNumItemHandle, &dwValue);
                                pThisItem->FirstValue = (LONGLONG)dwValue;

                                assert ((pCounter->lDenItemType == VT_I4) ||
                                        (pCounter->lDenItemType == VT_UI4));
                                pWbemAccess->ReadDWORD (
                                        pCounter->lDenItemHandle, &dwValue);
                                // the denominator should be a 32-bit value
                                pThisItem->SecondValue = (LONGLONG)dwValue;
                                break;

                            case PERF_LARGE_RAW_FRACTION:
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I8) ||
                                        (pCounter->lNumItemType == VT_UI8));
                                pCounter->pWbemAccess->ReadQWORD (
                                    pCounter->lNumItemHandle, & llValue);
                                pCounter->ThisValue.FirstValue = (LONGLONG) llValue;

                                assert ((pCounter->lDenItemType == VT_I8) ||
                                        (pCounter->lDenItemType == VT_UI8));
                                pCounter->pWbemAccess->ReadQWORD (
                                    pCounter->lDenItemHandle, & llValue);
                                // the denominator should be a 32-bit value
                                pCounter->ThisValue.SecondValue = (LONGLONG) llValue;
                            break;

                            case PERF_AVERAGE_TIMER:
                            case PERF_AVERAGE_BULK:
                                // counter (numerator) is a LONGLONG, while the
                                // denominator is just a DWORD
                                // this should be a DWORD counter
                                assert ((pCounter->lNumItemType == VT_I8) ||
                                        (pCounter->lNumItemType == VT_UI8));
                                pWbemAccess->ReadQWORD (
                                        pCounter->lNumItemHandle, &llValue);
                                pThisItem->FirstValue = (LONGLONG)llValue;

                                assert ((pCounter->lDenItemType == VT_I4) ||
                                        (pCounter->lDenItemType == VT_UI4));
                                pWbemAccess->ReadDWORD (
                                        pCounter->lDenItemHandle, &dwValue);
                                // the denominator should be a 32-bit value
                                pThisItem->SecondValue = (LONGLONG)dwValue;

                                // look up the timebase freq if necessary
                                if (pCounter->TimeBase == 0) {
                                    assert ((pCounter->lFreqItemType == VT_I8) ||
                                            (pCounter->lFreqItemType == VT_UI8));
                                    pWbemAccess->ReadQWORD (
                                            pCounter->lFreqItemHandle, &llValue);
                                    // the timebase is a 64 bit integer
                                    pCounter->TimeBase = llValue;
                                }
                                break;
                            //
                            //  These counters are used as the part of another counter
                            //  and as such should not be used, but in case they are
                            //  they'll be handled here.
                            //
                            case PERF_SAMPLE_BASE:
                            case PERF_AVERAGE_BASE:
                            case PERF_COUNTER_MULTI_BASE:
                            case PERF_RAW_BASE:
                            case PERF_LARGE_RAW_BASE:
                                pThisItem->FirstValue = 0;
                                pThisItem->SecondValue = 0;
                                break;

                            //
                            //  These counters are not supported by this function (yet)
                            //
                            case PERF_COUNTER_TEXT:
                            case PERF_COUNTER_NODATA:
                            case PERF_COUNTER_HISTOGRAM_TYPE:
                                pThisItem->FirstValue = 0;
                                pThisItem->SecondValue = 0;
                                break;

                            case PERF_100NSEC_MULTI_TIMER:
                            case PERF_100NSEC_MULTI_TIMER_INV:
                            default:
                                // an unidentified  or unsupported
                                // counter was returned so
                                pThisItem->FirstValue = 0;
                                pThisItem->SecondValue = 0;
                                bReturn = FALSE;
                                break;
                        }
                        // we're done with this one so release it
                        pWbemAccess->Release();
                    }
                    // measure the memory block used
                    assert (dwFinalSize == (DWORD)((LPBYTE)szNextNameString -
                            (LPBYTE)(pCounter->pThisRawItemList)));

                    pCounter->pThisRawItemList->dwLength = dwFinalSize;
                    pCounter->pThisRawItemList->dwItemCount = lNumInstances;
                    pCounter->pThisRawItemList->dwReserved = 0;
                    pCounter->pThisRawItemList->CStatus = ERROR_SUCCESS;

                    pCounter->pThisRawItemList->TimeStamp = *pTimestamp;

                } else {
                    // unable to allocate a new buffer so return error
                    SetLastError (ERROR_OUTOFMEMORY);
                    bReturn = FALSE;
                }
            }
        }
    }
    return bReturn;
}

LONG
GetQueryWbemData (
    IN  PPDHI_QUERY         pQuery,
    IN  LONGLONG            *pllTimeStamp
)
{
    FILETIME            GmtFileTime;
    FILETIME            LocFileTime;
    LONGLONG            llTimeStamp = 0;
    HRESULT             hRes;
    LONG                lRetStatus = ERROR_SUCCESS;\

    PPDHI_COUNTER       pCounter;
    PDH_STATUS          pdhStatus;

    // refresh Wbem Refresher

    if (bDontRefresh) return ERROR_BUSY;

    if (pQuery->pRefresher != NULL) {
        hRes = pQuery->pRefresher->Refresh(0);
    } else {
        hRes = WBEM_E_INITIALIZATION_FAILURE;
    }

    // If multiple objects are being refreshed, some objects may succeed and
    // others may fail, in which case WBEM_S_PARTIAL_RESULTS is returned.

    if ( FAILED( hRes ) ) {
        SetLastError (hRes);
        lRetStatus = PDH_WBEM_ERROR;
    }

    if (lRetStatus == ERROR_SUCCESS) {
        // get timestamp for this counter
        GetSystemTimeAsFileTime(& GmtFileTime);
        FileTimeToLocalFileTime(& GmtFileTime, & LocFileTime);
        llTimeStamp = MAKELONGLONG(LocFileTime.dwLowDateTime,
                                   LocFileTime.dwHighDateTime);

        // now update the counters using this new data
        if ((pCounter = pQuery->pCounterListHead) != NULL) {
            do {
                if (pCounter->dwFlags & PDHIC_MULTI_INSTANCE) {
                    pdhStatus = UpdateWbemMultiInstanceCounterValue (
                        pCounter, (FILETIME *)&llTimeStamp);
                } else {
                    // update single instance counter values
                    pdhStatus = UpdateWbemCounterValue (pCounter,
                        (FILETIME *)&llTimeStamp);
                }
                pCounter = pCounter->next.flink;
            } while (pCounter != pQuery->pCounterListHead);
            pdhStatus = ERROR_SUCCESS;
        } else {
            // no counters in the query  (?!)
            pdhStatus = PDH_NO_DATA;
        }
        lRetStatus = pdhStatus;
    }
    
    *pllTimeStamp = llTimeStamp;

    return lRetStatus;
}

HRESULT WbemSetProxyBlanket(
    IUnknown                 *pInterface,
    DWORD                     dwAuthnSvc,
    DWORD                     dwAuthzSvc,
    OLECHAR                  *pServerPrincName,
    DWORD                     dwAuthLevel,
    DWORD                     dwImpLevel,
    RPC_AUTH_IDENTITY_HANDLE  pAuthInfo,
    DWORD                     dwCapabilities )
{
    // Security MUST be set on both the Proxy and it's IUnknown!

    IUnknown * pUnk = NULL;
    IClientSecurity * pCliSec = NULL;
    HRESULT sc = pInterface->QueryInterface(IID_IUnknown, (void **) &pUnk);
    if(sc != S_OK)
        return sc;
    sc = pInterface->QueryInterface(IID_IClientSecurity, (void **) &pCliSec);
    if(sc != S_OK)
    {
        pUnk->Release();
        return sc;
    }
    sc = pCliSec->SetBlanket(pInterface, dwAuthnSvc, dwAuthzSvc, pServerPrincName,
        dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities);
    pCliSec->Release();
    pCliSec = NULL;
    sc = pUnk->QueryInterface(IID_IClientSecurity, (void **) &pCliSec);
    if(sc == S_OK)
    {
        sc = pCliSec->SetBlanket(pUnk, dwAuthnSvc, dwAuthzSvc, pServerPrincName,
            dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities);
        pCliSec->Release();
    }
    else if (sc == 0x80004002)
        sc = S_OK;
    pUnk->Release();
    return sc;
}