windows-server-2003/sdktools/pdh/pdhdll/vbfuncs.c

/*++
Copyright (C) 1995-1999 Microsoft Corporation

Module Name:
    vbfuncs.c

Abstract:
    Visual Basic interface functions exposed in pdh.dll
--*/
#include <windows.h>
#include "strsafe.h"
#include <winperf.h>
#include <pdh.h>
#include "pdhidef.h"
#include "pdhmsg.h"
#include "strings.h"

#define INITIAL_VB_LIST_SIZE (4096 * 4)
#define EXTEND_VB_LIST_SIZE  (4096 * 2)

typedef struct _VB_STRING_LIST {
    LPSTR   mszList;          // pointer to buffer containing strings
    LPSTR   szTermChar;       // pointer to "next" char to use
    DWORD   dwNumEntries;     // number of strings
    DWORD   dwSize;           // max size (in chars) of buffer
    DWORD   dwRemaining;      // # of chars left
    DWORD   dwLastEntryRead;  // index of last string read indicating index of....
    DWORD   dwLastItemLength; // length of last item read
    LPSTR   szLastItemRead;   // pointer to START of last item read
} VB_STRING_LIST, FAR * LPVB_STRING_LIST;

VB_STRING_LIST PdhivbList = { NULL, NULL, 0, 0, 0};

BOOL
PdhiAddStringToVbList(
    LPSTR szString
)
{
    DWORD             dwSize1, dwSize2;
    VB_STRING_LIST  * pVbList;
    BOOL              bReturn = FALSE;

    if (WAIT_FOR_AND_LOCK_MUTEX(hPdhDataMutex) == ERROR_SUCCESS) {
        dwSize1 = lstrlenA(szString) + 1;
        pVbList = & PdhivbList;
        if (dwSize1 > pVbList->dwRemaining) {
            LPSTR lpTmp = pVbList->mszList;

            dwSize2          = (DWORD) (pVbList->szTermChar - pVbList->mszList);
            pVbList->dwSize += EXTEND_VB_LIST_SIZE;
            pVbList->mszList = G_REALLOC(lpTmp, pVbList->dwSize);
            if (pVbList->mszList == NULL) {
                G_FREE(lpTmp);
                ZeroMemory(pVbList, sizeof(VB_STRING_LIST));
                RELEASE_MUTEX(hPdhDataMutex);
                goto Cleanup;
            }
            else {
                // update values
                pVbList->szLastItemRead = pVbList->mszList;
                pVbList->szTermChar     = pVbList->mszList + dwSize2;
                pVbList->dwRemaining   += EXTEND_VB_LIST_SIZE;
            }
        }
        // copy new string
        StringCchCopyA(pVbList->szTermChar, pVbList->dwSize, szString);
        pVbList->dwNumEntries ++;
        pVbList->szTermChar  += dwSize1;
        pVbList->dwRemaining -= dwSize1;
        RELEASE_MUTEX(hPdhDataMutex);
        bReturn = TRUE;
    }
Cleanup:
    return bReturn;
}

void
PdhiDialogCallBack(
    DWORD_PTR dwArg
)
{
    // add strings in buffer to list boxpfdh
    LPTSTR         NewCounterName;
    LPTSTR         NewCounterName2;
    LPTSTR         szExpandedPath;
    DWORD          dwSize1, dwSize2;
    PDH_STATUS    pdhStatus = ERROR_SUCCESS;
    PPDH_BROWSE_DLG_CONFIG    pDlgConfig;

    pDlgConfig = (PPDH_BROWSE_DLG_CONFIG)dwArg;

    if (pDlgConfig->CallBackStatus == PDH_MORE_DATA) {
        // transfer buffer is too small for selection so extend it and
        // try again.
        if (pDlgConfig->szReturnPathBuffer != NULL) {
            G_FREE (pDlgConfig->szReturnPathBuffer);
        }
        pDlgConfig->cchReturnPathLength += EXTEND_VB_LIST_SIZE;
        pDlgConfig->szReturnPathBuffer =
            G_ALLOC ((pDlgConfig->cchReturnPathLength * sizeof (CHAR)));

        if (pDlgConfig->szReturnPathBuffer != NULL) {
            pdhStatus = PDH_RETRY;
        } else {
            pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
        }
    } else {
        for (NewCounterName = pDlgConfig->szReturnPathBuffer;
            (*NewCounterName != 0) && (pdhStatus == ERROR_SUCCESS);
            NewCounterName += (lstrlen(NewCounterName) + 1)) {
            if (strstr (NewCounterName, caszSplat) == NULL) {
                // this is a regular path entry so add it to the VB List
                if (!PdhiAddStringToVbList (NewCounterName)) {
                    pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                }
            } else {
                szExpandedPath = G_ALLOC (INITIAL_VB_LIST_SIZE);
                if (szExpandedPath != NULL) {
                    // there's a wild card path character so expand it then enter them
                    // clear the list buffer
                    *(LPDWORD)szExpandedPath = 0;
                    dwSize1 = dwSize2 = INITIAL_VB_LIST_SIZE;
                    PdhExpandCounterPath (NewCounterName, szExpandedPath, &dwSize2);
                    if (dwSize2 < dwSize1) {
                        // then the returned buffer fit
                        for (NewCounterName2 = szExpandedPath;
                            *NewCounterName2 != 0;
                            NewCounterName2 += (lstrlen(NewCounterName2) + 1)) {

                            if (!PdhiAddStringToVbList (NewCounterName2)) {
                                pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                                break; //out of loop
                            }
                        }
                    } else {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                    G_FREE (szExpandedPath);
                } else {
                    SetLastError (PDH_MEMORY_ALLOCATION_FAILURE);
                }
            }
        }
        // clear buffer
        ZeroMemory(pDlgConfig->szReturnPathBuffer,
                   (pDlgConfig->cchReturnPathLength * sizeof(CHAR)));
    }
    pDlgConfig->CallBackStatus = pdhStatus;
    return;
}

double
PdhVbGetDoubleCounterValue(
    IN  PDH_HCOUNTER hCounter,
    IN  LPDWORD      pdwCounterStatus
)
/*++
Routine Description:
    retrieves the current value of the specified counter and returns the
        formatted version to the caller.

Arguments:
    IN  HCOUNTER hCounter
        pointer to the counter to get the data for
    IN LPDWORD  pdwCounterStatus
        status value of this counter. This value should be checked to
        insure the data is valid. If the status is not successful, then
        the data returned cannot be trusted and should not be used

Return Value:
    a double precesion floating point value of the current counter value
        formatted and computed as required by the counter type.
--*/
{
    PDH_STATUS  pdhStatus;
    PDH_FMT_COUNTERVALUE    pdhValue;
    DWORD       dwCounterType;
    double    dReturn;

    pdhStatus = PdhGetFormattedCounterValue (
        hCounter, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &dwCounterType, &pdhValue);

    if (pdhStatus == ERROR_SUCCESS) {
        // the function was successful so return the counter status
        // and the returned value
        pdhStatus = pdhValue.CStatus;
        dReturn = pdhValue.doubleValue;
    } else {
        // the function returned an error so return the
        // error in the status field & 0.0 for a value
        dReturn = 0.0f;
    }

    if (pdwCounterStatus != NULL) {
        __try {
            *pdwCounterStatus = pdhStatus;
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            // unable to write to status variable
            // don't worry about it, since it's optional and there's not much
            // we can do here anyway.
        }
    }
    return dReturn;
}

DWORD
PdhVbGetOneCounterPath(
    IN  LPSTR  szPathBuffer,
    IN  DWORD  cchBufferLength,
    IN  DWORD  dwDetailLevel,
    IN  LPCSTR szCaption
)
/*++
Routine Description:
    Retrieves one path string from the buffer of stored counter paths
        assembled by the most recent call to PdhVbCreateCounterPathList

Arguments:
    LPSTR   szPathBuffer
        string buffer to return selected counter path in
    DWORD   cchBufferLength
        size of string buffer in characters
    DWORD   dwDetailLevel
        detail level to filter the counters by
    LPCSTR  szCaption
        string to display in the caption bar

Return Value:
    returns the length of the path string in characters returned
        to the caller.
--*/
{
    PDH_BROWSE_DLG_CONFIG_A BrowseConfig;
    PDH_STATUS              PdhStatus = ERROR_SUCCESS;
    DWORD                   dwReturn = 0;

    // test access to caller supplied buffer
    __try {
        CHAR cChar;
        if ((cchBufferLength > 0) && (szPathBuffer != NULL)) {
            cChar                             = szPathBuffer[0];
            szPathBuffer[0]                   = '\0';
            szPathBuffer[0]                   = cChar;
            cChar                             = szPathBuffer[cchBufferLength - 1];
            szPathBuffer[cchBufferLength - 1] = '\0';
            szPathBuffer[cchBufferLength - 1] = cChar;
        }
        else {
            PdhStatus = PDH_INVALID_ARGUMENT;
        }

        if (szCaption != NULL) {
            cChar = * ((CHAR volatile *) szCaption);
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        PdhStatus = PDH_INVALID_ARGUMENT;
    }

    if (PdhStatus == ERROR_SUCCESS) {
        ZeroMemory(& BrowseConfig, sizeof(PDH_BROWSE_DLG_CONFIG_A));
        BrowseConfig.bIncludeInstanceIndex    = FALSE;
        BrowseConfig.bSingleCounterPerAdd     = TRUE;
        BrowseConfig.bSingleCounterPerDialog  = TRUE;
        BrowseConfig.bLocalCountersOnly       = FALSE;
        BrowseConfig.bWildCardInstances       = FALSE;
        BrowseConfig.bDisableMachineSelection = FALSE;
        BrowseConfig.bHideDetailBox           = (dwDetailLevel > 0 ? TRUE : FALSE);
        BrowseConfig.hWndOwner                = NULL;  // there should be some way to get this
        BrowseConfig.szReturnPathBuffer       = szPathBuffer;
        BrowseConfig.cchReturnPathLength      = cchBufferLength;
        BrowseConfig.pCallBack                = NULL;
        BrowseConfig.dwCallBackArg            = 0;
        // default is to show ALL counters
        BrowseConfig.dwDefaultDetailLevel     = (dwDetailLevel > 0 ? dwDetailLevel : PERF_DETAIL_WIZARD);
        BrowseConfig.szDialogBoxCaption       = (LPSTR) szCaption;

        PdhStatus = PdhBrowseCountersA(& BrowseConfig);
    }

    if (PdhStatus == ERROR_SUCCESS) {
        dwReturn = lstrlenA(szPathBuffer);
    }
    else {
        dwReturn = 0;
    }
    return dwReturn;
}

DWORD
PdhVbCreateCounterPathList(
    IN  DWORD  dwDetailLevel,
    IN  LPCSTR szCaption
)
/*++
Routine Description:
    Displays the counter browsing dialog box and allows the user to select
        multiple counter paths. As the paths are selected, they are stored
        in an internal buffer for later retrieval by the caller.

    NOTE, that calling this function will clear any previous selections.

Arguments:
    DWORD   dwDetailLevel
        detail level to filter the counters by
    LPCSTR  szCaption
        string to display in the caption bar

Return Value:
    returns the number of path strings selected by the user that must
        be retrieved by the caller.
--*/
{
    PDH_STATUS              PdhStatus = ERROR_SUCCESS;
    PDH_BROWSE_DLG_CONFIG_A BrowseConfig;
    DWORD                   dwReturn = 0;

    // test access to caller supplied buffer
    __try {
        CHAR cChar;
        if (szCaption != NULL) {
            cChar = * ((CHAR volatile *) szCaption);
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        PdhStatus = PDH_INVALID_ARGUMENT;
    }

    if (PdhStatus == ERROR_SUCCESS) {
        PdhStatus = WAIT_FOR_AND_LOCK_MUTEX(hPdhDataMutex);
        if (PdhStatus == ERROR_SUCCESS) {
            if (PdhivbList.mszList != NULL) {
                G_FREE(PdhivbList.mszList);
                ZeroMemory((LPVOID) & PdhivbList, sizeof(VB_STRING_LIST));
            }
            PdhivbList.mszList = G_ALLOC(INITIAL_VB_LIST_SIZE);
            if (PdhivbList.mszList != NULL) {
                PdhivbList.szLastItemRead   = PdhivbList.mszList;
                PdhivbList.szTermChar       = PdhivbList.mszList;
                PdhivbList.dwRemaining      = INITIAL_VB_LIST_SIZE;
                PdhivbList.dwSize           = INITIAL_VB_LIST_SIZE;
                PdhivbList.dwLastEntryRead  = 0;
                PdhivbList.dwLastItemLength = 0;
            }
            else {
                PdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
            }
            RELEASE_MUTEX(hPdhDataMutex);
        }
    }

    if (PdhStatus == ERROR_SUCCESS) {
        ZeroMemory(& BrowseConfig, sizeof(PDH_BROWSE_DLG_CONFIG_A));
        BrowseConfig.bIncludeInstanceIndex    = FALSE;
        BrowseConfig.bSingleCounterPerAdd     = FALSE;
        BrowseConfig.bSingleCounterPerDialog  = FALSE;
        BrowseConfig.bLocalCountersOnly       = FALSE;
        BrowseConfig.bWildCardInstances       = FALSE;
        BrowseConfig.bDisableMachineSelection = FALSE;
        BrowseConfig.bHideDetailBox           = (dwDetailLevel > 0 ? TRUE : FALSE);
        BrowseConfig.hWndOwner                = NULL;  // there should be some way to get this
        BrowseConfig.szReturnPathBuffer       = G_ALLOC (INITIAL_VB_LIST_SIZE);
        if (BrowseConfig.szReturnPathBuffer != NULL) {
            BrowseConfig.cchReturnPathLength  = (BrowseConfig.szReturnPathBuffer != NULL ? INITIAL_VB_LIST_SIZE : 0);
            BrowseConfig.pCallBack            = (CounterPathCallBack) PdhiDialogCallBack;
            BrowseConfig.dwCallBackArg        = (DWORD_PTR) & BrowseConfig;
            // default is to show ALL counters
            BrowseConfig.dwDefaultDetailLevel = (dwDetailLevel > 0 ? dwDetailLevel : PERF_DETAIL_WIZARD);
            BrowseConfig.szDialogBoxCaption   = (LPSTR)szCaption;

            PdhStatus = PdhBrowseCountersA(& BrowseConfig);
            if (BrowseConfig.szReturnPathBuffer != NULL) {
                G_FREE(BrowseConfig.szReturnPathBuffer);
            }
            dwReturn = PdhivbList.dwNumEntries;
        }
        else {
            SetLastError(PDH_MEMORY_ALLOCATION_FAILURE);
            dwReturn = 0;
        }
    }
    return dwReturn;
}

DWORD
PdhVbGetCounterPathFromList(
    IN  DWORD dwIndex,     // starting at 1 for VB types
    IN  LPSTR szBuffer,    // return buffer
    IN  DWORD dwBufferSize // size in chars of buffer
)
/*++
Routine Description:
    Displays the counter browsing dialog box and allows the user to select
        multiple counter paths. As the paths are selected, they are stored
        in an internal buffer for later retrieval by the caller.

    NOTE, that calling this function will clear any previous selections.

Arguments:
    DWORD       dwIndex
        The "1-based" index of the counter path to retrieve from
        the list of selected counter paths generated by the previous
        call to PdhVbCreateCounterPathList.
    LPSTR       szBuffer
        string buffer to return the selected string in
    DWORD       dwBufferSize
        size of the szBuffer in characters

Return Value:
    Returns the number of characters copied to the calling function
--*/
{
    DWORD dwBuffIndex;    // 0-based index for "c"
    DWORD dwThisIndex;
    DWORD dwCharsCopied;  // size of string not counting term NULL
    BOOL  bContinue = TRUE;

    dwBuffIndex   = dwIndex - 1;
    dwCharsCopied = 0;

    // validate the arguments
    __try {
        if (dwBufferSize > 0) {
            // try writing to ouput buffer
            szBuffer[0]                = '\0';
            szBuffer[dwBufferSize - 1] = '\0';
        }
        else {
            bContinue = FALSE;
        }
        if (dwBuffIndex >= PdhivbList.dwNumEntries) {
            bContinue = FALSE;
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        bContinue = FALSE;
    }

    if (WAIT_FOR_AND_LOCK_MUTEX(hPdhDataMutex) == ERROR_SUCCESS) {
        if (bContinue) {
            if (PdhivbList.szLastItemRead == NULL) {
                PdhivbList.szLastItemRead   = PdhivbList.mszList;
                PdhivbList.dwLastEntryRead  = 0;
                PdhivbList.dwLastItemLength = 0;
            }
            if (PdhivbList.szLastItemRead != NULL) {
                if (PdhivbList.dwLastItemLength == 0) {
                    PdhivbList.dwLastItemLength = lstrlen(PdhivbList.szLastItemRead) + 1;
                }
            }
            else {
                bContinue = FALSE;
            }
        }

        if (bContinue) {
            // see if this is the next entry
            if (dwBuffIndex == (PdhivbList.dwLastEntryRead + 1)) {
                PdhivbList.szLastItemRead  += PdhivbList.dwLastItemLength;
                PdhivbList.dwLastItemLength = lstrlen(PdhivbList.szLastItemRead) + 1;
                PdhivbList.dwLastEntryRead ++;
                if (PdhivbList.dwLastItemLength < dwBufferSize) {
                    StringCchCopyA(szBuffer, dwBufferSize, PdhivbList.szLastItemRead);
                    dwCharsCopied = PdhivbList.dwLastItemLength - 1;
                }
            }
            else if (dwBuffIndex == PdhivbList.dwLastEntryRead) {
                // it's this one (again)
                if (PdhivbList.dwLastItemLength < dwBufferSize) {
                    StringCchCopyA(szBuffer, dwBufferSize, PdhivbList.szLastItemRead);
                    dwCharsCopied = PdhivbList.dwLastItemLength - 1;
                }
            }
            else {
                // walk the list to the desired entry (ugh!)
                PdhivbList.szLastItemRead = PdhivbList.mszList;
                for (dwThisIndex = 0; dwThisIndex < dwBuffIndex; dwThisIndex++) {
                    PdhivbList.szLastItemRead += lstrlen(PdhivbList.szLastItemRead) + 1;
                }
                PdhivbList.dwLastItemLength = lstrlen(PdhivbList.szLastItemRead) + 1;
                PdhivbList.dwLastEntryRead  = dwThisIndex;
                if (PdhivbList.dwLastItemLength < dwBufferSize) {
                    StringCchCopyA(szBuffer, dwBufferSize, PdhivbList.szLastItemRead);
                    dwCharsCopied = PdhivbList.dwLastItemLength - 1;
                }
            }
        }
        RELEASE_MUTEX(hPdhDataMutex);
    }
    return dwCharsCopied;
}

DWORD
PdhVbGetCounterPathElements(
    IN  LPCSTR szPathString,
    IN  LPSTR  szMachineName,
    IN  LPSTR  szObjectName,
    IN  LPSTR  szInstanceName,
    IN  LPSTR  szParentInstance,
    IN  LPSTR  szCounterName,
    IN  DWORD  dwBufferSize
)
/*++
Routine Description:
    breaks the counter path provided in the szPathString argument and
        returns the components in the buffers provided by the caller.
        The buffers must be at least "dwBufferSize" in length.

Arguments:
    LPCSTR  szPathString
        pointer to the full counter path that is to be parsed into
        component strings
    LPSTR   szMachineName
        caller supplied buffer that is to receive the machine name.
        The buffer must be at least dwBufferSize in length.
    LPSTR   szObjectName
        caller supplied buffer that is to receive the object name.
        The buffer must be at least dwBufferSize in length.
    LPSTR   szInstanceName
        caller supplied buffer that is to receive the Instance name.
        The buffer must be at least dwBufferSize in length.
    LPSTR   szParentInstance
        caller supplied buffer that is to receive the parent instance name.
        The buffer must be at least dwBufferSize in length.
    LPSTR   szCounterName
        caller supplied buffer that is to receive the counter name.
        The buffer must be at least dwBufferSize in length.
    DWORD   dwBufferSize
        The buffer size of the caller supplied string buffers in characters

Return Value:
    ERROR_SUCCESS if the counter string is successfully parsed, otherwise
        a PDH error if not.
    PDH_INVALID_ARGUMENT if one or more of the string buffers is not
        the correct size
    PDH_INSUFFICIENT_BUFFER if one or more of the counter path elements
        is too large for the return buffer length.
    PDH_MEMORY_ALLOCATION_FAILURE if a temporary memory buffer could not
        be allocated.
--*/
{
    PPDH_COUNTER_PATH_ELEMENTS_A pInfo;
    PDH_STATUS                   pdhStatus = ERROR_SUCCESS;
    DWORD                        dwSize;

    // validate the return arguments
    __try {
        CHAR    cChar;
        if (szPathString != NULL) {
            cChar = * ((CHAR volatile *) szPathString);
            if (cChar == 0) {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }
        else {
            pdhStatus = PDH_INVALID_ARGUMENT;
        }

        if (pdhStatus == ERROR_SUCCESS){
            if (szMachineName != NULL) {
                szMachineName[0]                = '\0';
                szMachineName[dwBufferSize - 1] = '\0';
            }
            else {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }

        if (pdhStatus == ERROR_SUCCESS){
            if (szObjectName != NULL) {
                szObjectName[0]                = '\0';
                szObjectName[dwBufferSize - 1] = '\0';
            }
            else {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }

        if (pdhStatus == ERROR_SUCCESS){
            if (szInstanceName != NULL) {
                szInstanceName[0]                = '\0';
                szInstanceName[dwBufferSize - 1] = '\0';
            }
            else {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }

        if (pdhStatus == ERROR_SUCCESS){
            if (szParentInstance != NULL) {
                szParentInstance[0]                = '\0';
                szParentInstance[dwBufferSize - 1] = '\0';
            }
            else {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }


        if (pdhStatus == ERROR_SUCCESS){
            if (szCounterName != NULL) {
                szCounterName[0]                = '\0';
                szCounterName[dwBufferSize - 1] = '\0';
            } else {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        pdhStatus = PDH_INVALID_ARGUMENT;
    }

    if (pdhStatus == ERROR_SUCCESS) {
        // allocate temp buffer for component strings
        dwSize = (5 * dwBufferSize) + sizeof(PDH_COUNTER_INFO_A);
        pInfo = G_ALLOC (dwSize);
        if (pInfo != NULL) {
            pdhStatus = PdhParseCounterPathA(szPathString, pInfo, & dwSize, 0);
            if (pdhStatus == ERROR_SUCCESS) {
                // move from local structure to user args if the strings will fit
                if (pInfo->szMachineName != NULL) {
                    if (FAILED(StringCchCopyA(szMachineName, dwBufferSize, pInfo->szMachineName))) {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                }

                if (pInfo->szObjectName != NULL) {
                    if (FAILED(StringCchCopyA(szObjectName, dwBufferSize, pInfo->szObjectName))) {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                }

                if (pInfo->szInstanceName != NULL) {
                    if (FAILED(StringCchCopyA(szInstanceName, dwBufferSize, pInfo->szInstanceName))) {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                }

                if (pInfo->szParentInstance != NULL) {
                    if (FAILED(StringCchCopyA(szParentInstance, dwBufferSize, pInfo->szParentInstance))) {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                }

                if (pInfo->szCounterName != NULL) {
                    if (FAILED(StringCchCopyA(szCounterName, dwBufferSize, pInfo->szCounterName))) {
                        pdhStatus = PDH_INSUFFICIENT_BUFFER;
                    }
                }
            } // else pass error to caller
            G_FREE (pInfo);
        }
        else {
            pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
        }
    } // else pass error to caller

    return pdhStatus;
}

DWORD
PdhVbAddCounter(
    IN  PDH_HQUERY     hQuery,
    IN  LPCSTR         szFullCounterPath,
    IN  PDH_HCOUNTER * hCounter
)
/*++
Routine Description:
    Creates and initializes a counter structure and attaches it to the
        specified query by calling the C function.

Arguments:
    IN  HQUERY  hQuery
        handle of the query to attach this counter to once the counter
        entry has been successfully created.
    IN  LPCSTR szFullCounterPath
        pointer to the path string that describes the counter to add to
        the query referenced above. This string must specify a single
        counter. Wildcard path strings are not permitted.
    IN  HCOUNTER *phCounter
        pointer to the buffer that will get the handle value of the
        successfully created counter entry.

Return Value:
    Returns ERROR_SUCCESS if a new query was created and initialized,
        and a PDH_ error value if not.
    PDH_INVALID_ARGUMENT is returned when one or more of the arguements
        is invalid or incorrect.
    PDH_MEMORY_ALLOCATION_FAILURE is returned when a memory buffer could
        not be allocated.
    PDH_INVALID_HANDLE is returned if the query handle is not valid.
    PDH_CSTATUS_NO_COUNTER is returned if the specified counter was
        not found
    PDH_CSTATUS_NO_OBJECT is returned if the specified object could
        not be found
    PDH_CSTATUS_NO_MACHINE is returned if a machine entry could not
        be created.
    PDH_CSTATUS_BAD_COUNTERNAME is returned if the counter name path
        string could not be parsed or interpreted
    PDH_CSTATUS_NO_COUNTERNAME is returned if an empty counter name
        path string is passed in
    PDH_FUNCTION_NOT_FOUND is returned if the calculation function
        for this counter could not be determined.
--*/
{
    DWORD        dwReturn      = ERROR_SUCCESS;
    PDH_HCOUNTER hLocalCounter = NULL;

    if ((hCounter == NULL) || (szFullCounterPath == NULL)) {
        dwReturn = PDH_INVALID_ARGUMENT;
    }
    else {
        dwReturn = PdhAddCounterA(hQuery, szFullCounterPath, 0, & hLocalCounter);
    }

    if (dwReturn == ERROR_SUCCESS) {
        __try {
            * hCounter = hLocalCounter;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
            dwReturn = PDH_INVALID_ARGUMENT;
        }
    }
    return dwReturn;
}

DWORD
PdhVbOpenQuery(
    IN  PDH_HQUERY * phQuery
)
/*++
Routine Description:
    allocates a new query structure for a VB app by calling the "C"
    function with the rest of the arguments supplied

Arguments:
    IN  HQUERY  *phQuery
        pointer to the buffer that will receive the query handle opened.

Return Value:
    Returns ERROR_SUCCESS if a new query was created and initialized,
        and a PDH_ error value if not.
    PDH_INVALID_ARGUMENT is returned when one or more of the arguements
        is invalid or incorrect.
    PDH_MEMORY_ALLOCATION_FAILURE is returned when a memory buffer could
        not be allocated.
--*/
{
    DWORD      dwReturn    = ERROR_SUCCESS;
    PDH_HQUERY hLocalQuery = NULL;

    if (phQuery == NULL) {
        dwReturn = PDH_INVALID_ARGUMENT;
    }
    else {
        dwReturn = PdhOpenQuery(NULL, 0, & hLocalQuery);
    }

    if (dwReturn == ERROR_SUCCESS) {
        __try {
            * phQuery = hLocalQuery;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
            dwReturn = PDH_INVALID_ARGUMENT;
        }
    }
    return dwReturn;
}

DWORD
PdhVbIsGoodStatus(
    IN  LONG lStatus
)
/*++
Routine Description:
    Checks the status severity of the PDH status value
    passed into the function as a binary Good (TRUE)/Bad (FALSE)
    value.

Arguments:
    IN  LONG lStatus
        Status code to test

Return Value:
    TRUE  if the status code is Success or Informational severity
    FALSE if the status code is Error or Warning severity
--*/
{
    BOOL   bReturn;

    if (lStatus == ERROR_SUCCESS) {
        bReturn = TRUE;
    }
    else if (IsSuccessSeverity(lStatus)) {
        bReturn = TRUE;
    }
    else if (IsInformationalSeverity(lStatus)) {
        bReturn = TRUE;
    }
    else {
        bReturn = FALSE;
    }

    return (DWORD) bReturn;
}

DWORD
PdhVbOpenLog(
    IN  LPCSTR     szLogFileName,
    IN  DWORD      dwAccessFlags,
    IN  LPDWORD    lpdwLogType,
    IN  HQUERY     hQuery,
    IN  DWORD      dwMaxSize,
    IN  LPCSTR     szUserCaption,
    IN  PDH_HLOG * phLog
)
/*++
Routine Description:

Arguments:
    IN      LPCSTR  szLogFileName,
    IN      DWORD   dwAccessFlags,
    IN      LPDWORD lpdwLogType,
    IN      HQUERY  hQuery,
    IN      DWORD   dwMaxSize,
    IN      LPCSTR  szUserCaption,
    IN      HLOG    * phLog

Return Value:
    TRUE  if the status code is Success or Informational severity
    FALSE if the status code is Error or Warning severity
--*/
{
    return PdhOpenLogA(szLogFileName, dwAccessFlags, lpdwLogType, hQuery, dwMaxSize, szUserCaption, phLog);
}

DWORD
PdhVbUpdateLog(
    IN  PDH_HLOG hLog,
    IN  LPCSTR   szUserString
)
/*++
Routine Description:

Arguments:
    IN      HLOG    hLog,
    IN      LPCWSTR szUserString

Return Value:
    TRUE  if the status code is Success or Informational severity
    FALSE if the status code is Error or Warning severity
--*/
{
    return PdhUpdateLogA(hLog, szUserString);
}

DWORD 
PdhVbGetLogFileSize(
    IN  PDH_HLOG   hLog,
    IN  LONG     * lSize      
)
/*++
Routine Description:

Arguments:
    IN      HLOG       hLog,
    IN      LONGLONG * llSize     

Return Value:
    TRUE  if the status code is Success or Informational severity
    FALSE if the status code is Error or Warning severity
--*/
{
    PDH_STATUS  pdhStatus;
    LONGLONG    llTemp;

    pdhStatus = PdhGetLogFileSize(hLog, & llTemp);
    if (pdhStatus == ERROR_SUCCESS) {
        if (llTemp > 0x0000000080000000) {
            // file size is larger than a long value
            pdhStatus = PDH_INSUFFICIENT_BUFFER;
        }
        else {
            __try {
                * lSize = (LONG) (llTemp & 0x000000007FFFFFFF);
            }
            __except (EXCEPTION_EXECUTE_HANDLER) {
                pdhStatus = PDH_INVALID_ARGUMENT;
            }
        }
    }
    return pdhStatus;
}