/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
dnsperf.c
Abstract:
This file implements the Extensible Objects for the DNS object type
Created:
Jing Chen 1998
Revision History
--*/
//
// Include Files
//
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <rpc.h>
#include <wchar.h>
#include <winperf.h>
#include "perfutil.h"
#include "datadns.h"
#include "dnsperf.h"
#include "perfconfig.h"
#include "dnslibp.h" // security routine
#define SERVICE_NAME "DNS"
//
// DNS counter data structures
//
DWORD dwOpenCount = 0; // count of "Open" threads
BOOL bInitOK = FALSE; // true = DLL initialized OK
HANDLE hDnsSharedMemory = NULL; // Handle of Dns Shared Memory
PDWORD pCounterBlock = NULL;
extern DNS_DATA_DEFINITION DnsDataDefinition;
//
// Function Prototypes
//
// these are used to insure that the data collection functions
// accessed by Perflib will have the correct calling format.
//
PM_OPEN_PROC OpenDnsPerformanceData;
PM_COLLECT_PROC CollectDnsPerformanceData;
PM_CLOSE_PROC CloseDnsPerformanceData;
DWORD
OpenDnsPerformanceData(
IN LPWSTR lpDeviceNames
)
/*++
Routine Description:
This routine will open and map the memory used by the DNS to
pass performance data in. This routine also initializes the data
structures used to pass data back to the registry
Arguments:
Pointer to object ID of each device to be opened (DNS), which
seems to be totally unused, just as it was in the sample code
from which this is stolen.
Return Value:
None.
--*/
{
LONG status;
HKEY hKeyDriverPerf = NULL;
DWORD size;
DWORD type;
DWORD dwFirstCounter;
DWORD dwFirstHelp;
//
// Since SCREG is multi-threaded and will call this routine in
// order to service remote performance queries, this library
// must keep track of how many times it has been opened (i.e.
// how many threads have accessed it). the registry routines will
// limit access to the initialization routine to only one thread
// at a time so synchronization (i.e. reentrancy) should not be
// a problem
//
// DNS_FIX0: possible MT issues in dnsperf
// - thread counter is not protected, needs Interlocked instruction
// - contrary to above, reentrancy is not protected as we do
// file mapping first
// - file mapping not cleaned up on failure
// - registry handle not cleaned up on failure
//
if ( !dwOpenCount )
{
// open shared memory used by device driver to pass performance values
hDnsSharedMemory = OpenFileMapping(
FILE_MAP_READ,
FALSE,
DNS_PERF_COUNTER_BLOCK );
pCounterBlock = NULL; // initialize pointer to memory
if ( hDnsSharedMemory == NULL )
{
#if 0
//
// kill off NULL DACL code
//
/* maybe the DNS isn't running, and we should alloc the memory? */
SECURITY_ATTRIBUTES SA, *pSA;
BYTE rgbSD[SECURITY_DESCRIPTOR_MIN_LENGTH];
PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR) rgbSD;
pSA = &SA;
pSA->nLength = sizeof(SA);
pSA->lpSecurityDescriptor = pSD;
pSA->bInheritHandle = FALSE;
if ( !InitializeSecurityDescriptor(
pSD,
SECURITY_DESCRIPTOR_REVISION) ||
! SetSecurityDescriptorDacl( pSD, TRUE, (PACL) NULL, FALSE) )
{
pSA = NULL;
}
#endif
//
// create security on perfmon mapped file
//
// security will be AuthenticatedUsers get to read
// note, using array syntax, to make it easier to tweak
// if want other ACLs later
//
SID_IDENTIFIER_AUTHORITY ntAuthority = SECURITY_NT_AUTHORITY;
SECURITY_ATTRIBUTES secAttr;
PSECURITY_ATTRIBUTES psecAttr = NULL;
PSECURITY_DESCRIPTOR psd = NULL;
DWORD maskArray[ 3 ] = { 0 };
PSID sidArray[ 3 ] = { 0 }; // NULL terminated!
INT i;
maskArray[ 0 ] = GENERIC_READ;
status = RtlAllocateAndInitializeSid(
&ntAuthority,
1,
SECURITY_AUTHENTICATED_USER_RID,
0, 0, 0, 0, 0, 0, 0,
&sidArray[ 0 ] );
if ( status != ERROR_SUCCESS )
{
maskArray[ 1 ] = GENERIC_ALL;
status = RtlAllocateAndInitializeSid(
&ntAuthority,
1,
SECURITY_LOCAL_SYSTEM_RID,
0, 0, 0, 0, 0, 0, 0,
&sidArray[ 1 ] );
}
if ( status != ERROR_SUCCESS )
{
DNS_PRINT((
"ERROR <%lu>: Cannot create Authenticated Users SID\n",
status ));
}
else
{
status = Dns_CreateSecurityDescriptor(
&psd,
2, // number of ACEs
sidArray,
maskArray );
if ( status == ERROR_SUCCESS )
{
secAttr.lpSecurityDescriptor = psd;
secAttr.bInheritHandle = FALSE;
secAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
psecAttr = &secAttr;
}
ELSE
{
DNSDBG( ANY, (
"ERROR: <%d> failed SD create for perfmon memory!\n",
status ));
}
}
hDnsSharedMemory = CreateFileMapping(
(HANDLE) (-1),
psecAttr,
PAGE_READWRITE,
0,
4096,
DNS_PERF_COUNTER_BLOCK);
for ( i = 0; sidArray[ i ]; ++i )
{
RtlFreeSid( sidArray[ i ] );
}
if ( psd )
{
Dns_Free( psd );
}
}
// log error if unsuccessful
if ( hDnsSharedMemory == NULL )
{
// this is fatal, if we can't get data then there's no
// point in continuing.
status = GetLastError(); // return error
goto OpenFailed;
}
else
{
// if opened ok, then map pointer to memory
pCounterBlock = (PDWORD) MapViewOfFile(
hDnsSharedMemory,
FILE_MAP_READ,
0,
0,
0);
if (pCounterBlock == NULL)
{
// this is fatal, if we can't get data then there's no
// point in continuing.
status = GetLastError(); // return error
goto OpenFailed;
}
}
// get counter and help index base values from registry
// Open key to registry entry
// read First Counter and First Help values
// update static data strucutures by adding base to
// offset value in structure.
status = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\" SERVICE_NAME "\\Performance",
0L,
KEY_READ,
&hKeyDriverPerf);
if (status != ERROR_SUCCESS)
{
LPTSTR apsz[2];
// this is fatal, if we can't get the base values of the
// counter or help names, then the names won't be available
// to the requesting application so there's not much
// point in continuing.
apsz[0] = (LPTSTR) (LONG_PTR) status;
apsz[1] = "SYSTEM\\CurrentControlSet\\Services\\" SERVICE_NAME "\\Performance";
goto OpenFailed;
}
size = sizeof (DWORD);
status = RegQueryValueEx(
hKeyDriverPerf,
"First Counter",
0L,
&type,
(LPBYTE)&dwFirstCounter,
&size);
if (status != ERROR_SUCCESS) {
LPTSTR apsz[2];
// this is fatal, if we can't get the base values of the
// counter or help names, then the names won't be available
// to the requesting application so there's not much
// point in continuing.
apsz[0] = (LPTSTR) (LONG_PTR) status;
apsz[1] = "First Counter";
goto OpenFailed;
}
size = sizeof (DWORD);
status = RegQueryValueEx(
hKeyDriverPerf,
"First Help",
0L,
&type,
(LPBYTE)&dwFirstHelp,
&size);
if (status != ERROR_SUCCESS)
{
LPTSTR apsz[2];
// this is fatal, if we can't get the base values of the
// counter or help names, then the names won't be available
// to the requesting application so there's not much
// point in continuing.
apsz[0] = (LPTSTR) (LONG_PTR) status;
apsz[1] = "First Help";
goto OpenFailed;
}
//
// NOTE: the initialization program could also retrieve
// LastCounter and LastHelp if they wanted to do
// bounds checking on the new number. e.g.
//
// counter->CounterNameTitleIndex += dwFirstCounter;
// if (counter->CounterNameTitleIndex > dwLastCounter) {
// LogErrorToEventLog (INDEX_OUT_OF_BOUNDS);
// }
DnsDataDefinition.DnsObjectType.ObjectNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DnsObjectType.ObjectHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TotalQueryReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TotalQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TotalQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TotalQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.UdpQueryReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.UdpQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.UdpQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.UdpQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TcpQueryReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TcpQueryReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TcpQueryReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TcpQueryReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TotalResponseSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TotalResponseSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TotalResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TotalResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.UdpResponseSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.UdpResponseSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.UdpResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.UdpResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TcpResponseSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TcpResponseSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TcpResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TcpResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveQueries.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveQueries.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveQueries_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveQueries_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveTimeOut.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveTimeOut.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveTimeOut_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveTimeOut_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveQueryFailure.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveQueryFailure.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecursiveQueryFailure_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecursiveQueryFailure_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.NotifySent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.NotifySent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.ZoneTransferRequestReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.ZoneTransferRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.ZoneTransferSuccess.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.ZoneTransferSuccess.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.ZoneTransferFailure.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.ZoneTransferFailure.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.AxfrRequestReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.AxfrRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.AxfrSuccessSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.AxfrSuccessSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrRequestReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrRequestReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrSuccessSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrSuccessSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.NotifyReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.NotifyReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.ZoneTransferSoaRequestSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.ZoneTransferSoaRequestSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.AxfrRequestSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.AxfrRequestSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.AxfrResponseReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.AxfrResponseReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.AxfrSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.AxfrSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrRequestSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrRequestSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrResponseReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrResponseReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrUdpSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrUdpSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.IxfrTcpSuccessReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.IxfrTcpSuccessReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsLookupReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsLookupReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsLookupReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsLookupReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsResponseSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsResponseSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsReverseLookupReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsReverseLookupReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsReverseLookupReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsReverseLookupReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsReverseResponseSent.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsReverseResponseSent.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.WinsReverseResponseSent_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.WinsReverseResponseSent_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateNoOp.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateNoOp.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateNoOp_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateNoOp_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateWriteToDB.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateWriteToDB.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateWriteToDB_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateWriteToDB_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateRejected.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateRejected.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateTimeOut.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateTimeOut.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DynamicUpdateQueued.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DynamicUpdateQueued.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.SecureUpdateReceived.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.SecureUpdateReceived.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.SecureUpdateReceived_s.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.SecureUpdateReceived_s.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.SecureUpdateFailure.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.SecureUpdateFailure.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.DatabaseNodeMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.DatabaseNodeMemory.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.RecordFlowMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.RecordFlowMemory.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.CachingMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.CachingMemory.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.UdpMessageMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.UdpMessageMemory.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.TcpMessageMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.TcpMessageMemory.CounterHelpTitleIndex += dwFirstHelp;
DnsDataDefinition.NbstatMemory.CounterNameTitleIndex += dwFirstCounter;
DnsDataDefinition.NbstatMemory.CounterHelpTitleIndex += dwFirstHelp;
RegCloseKey( hKeyDriverPerf ); // close key to registry
bInitOK = TRUE; // ok to use this function
}
dwOpenCount++; // increment OPEN counter
return( ERROR_SUCCESS ); // for successful exit
OpenFailed:
//
// close handles if open fails
//
if ( hKeyDriverPerf )
{
RegCloseKey( hKeyDriverPerf );
}
if ( pCounterBlock )
{
UnmapViewOfFile( pCounterBlock );
pCounterBlock = NULL;
}
if ( hDnsSharedMemory )
{
CloseHandle( hDnsSharedMemory );
hDnsSharedMemory = NULL;
}
return status;
}
DWORD
CollectDnsPerformanceData(
IN LPWSTR lpValueName,
IN OUT LPVOID * lppData,
IN OUT LPDWORD lpcbTotalBytes,
IN OUT LPDWORD lpNumObjectTypes
)
/*++
Routine Description:
This routine will return the data for the DNS counters.
Arguments:
IN LPWSTR lpValueName
pointer to a wide character string passed by registry.
IN OUT LPVOID *lppData
IN: pointer to the address of the buffer to receive the completed
PerfDataBlock and subordinate structures. This routine will
append its data to the buffer starting at the point referenced
by *lppData.
OUT: points to the first byte after the data structure added by this
routine. This routine updated the value at lppdata after appending
its data.
IN OUT LPDWORD lpcbTotalBytes
IN: the address of the DWORD that tells the size in bytes of the
buffer referenced by the lppData argument
OUT: the number of bytes added by this routine is writted to the
DWORD pointed to by this argument
IN OUT LPDWORD NumObjectTypes
IN: the address of the DWORD to receive the number of objects added
by this routine
OUT: the number of objects added by this routine is writted to the
DWORD pointed to by this argument
Return Value:
ERROR_MORE_DATA if buffer passed is too small to hold data
any error conditions encountered are reported to the event log if
event logging is enabled.
ERROR_SUCCESS if success or any other error. Errors, however are
also reported to the event log.
--*/
{
// Variables for reformating the data
ULONG SpaceNeeded;
PDWORD pdwCounter;
PERF_COUNTER_BLOCK *pPerfCounterBlock;
DNS_DATA_DEFINITION *pDnsDataDefinition;
DWORD dwQueryType; // for error logging
//
// before doing anything else, see if Open went OK
//
if (!bInitOK)
{
// unable to continue because open failed.
*lpcbTotalBytes = (DWORD) 0;
*lpNumObjectTypes = (DWORD) 0;
return ERROR_SUCCESS; // yes, this is a successful exit
}
// see if this is a foreign (i.e. non-NT) computer data request
//
dwQueryType = GetQueryType (lpValueName);
if ( dwQueryType == QUERY_FOREIGN )
{
// this routine does not service requests for data from
// Non-NT computers
*lpcbTotalBytes = (DWORD) 0;
*lpNumObjectTypes = (DWORD) 0;
return ERROR_SUCCESS;
}
if (dwQueryType == QUERY_ITEMS)
{
if ( ! IsNumberInUnicodeList(
DnsDataDefinition.DnsObjectType.ObjectNameTitleIndex,
lpValueName ) )
{
// request received for data object not provided by this routine
*lpcbTotalBytes = (DWORD) 0;
*lpNumObjectTypes = (DWORD) 0;
return ERROR_SUCCESS;
}
}
//
// Get the data.
//
pDnsDataDefinition = (DNS_DATA_DEFINITION *) *lppData;
SpaceNeeded = sizeof(DNS_DATA_DEFINITION) + SIZE_OF_DNS_PERFORMANCE_DATA;
if ( *lpcbTotalBytes < SpaceNeeded )
{
*lpcbTotalBytes = (DWORD) 0;
*lpNumObjectTypes = (DWORD) 0;
return ERROR_MORE_DATA;
}
//
// Copy the (constant, initialized) Object Type and counter definitions
// to the caller's data buffer
//
memmove(pDnsDataDefinition,
&DnsDataDefinition,
sizeof(DNS_DATA_DEFINITION));
// Format and collect DNS data from shared memory
// The counter block is to immediately follow the data definition,
// so obtain a pointer to that space
pPerfCounterBlock = (PERF_COUNTER_BLOCK *) &pDnsDataDefinition[1];
// The byte length is of the counter block header and all following data
pPerfCounterBlock->ByteLength = SIZE_OF_DNS_PERFORMANCE_DATA;
// Compute a pointer to the buffer immediately following the counter
// block header
pdwCounter = (PDWORD) (&pPerfCounterBlock[1]);
// copy the counter data from shared memory block into the counter block
memcpy(pdwCounter,
&pCounterBlock[1],
SIZE_OF_DNS_PERFORMANCE_DATA - sizeof(PERF_COUNTER_BLOCK));
// Tell caller where the next available byte is
*lppData = (PVOID) ((PBYTE)pdwCounter + SIZE_OF_DNS_PERFORMANCE_DATA - sizeof(PERF_COUNTER_BLOCK));
// update arguments before return
*lpNumObjectTypes = 1;
*lpcbTotalBytes = (DWORD) ((PBYTE)*lppData - (PBYTE)pDnsDataDefinition);
return ERROR_SUCCESS;
}
DWORD
CloseDnsPerformanceData(
VOID
)
/*++
Routine Description:
This routine closes the open handles to DNS device performance counters
Arguments:
None.
Return Value:
ERROR_SUCCESS
--*/
{
//
// cleanup when close last thread
//
// DNS_FIX0: MT issues in dnsperf cleanup
// no real protection on thread count (need interlock)
// but also close can be going on concurrently with another
// thread attempting to reopen (unlikely but possible)
//
// perhaps two flag approach would work, with all new threads
// failing (not passing through but skipping open altogether)
// until pCounterBlock was NULL again
//
if ( !(--dwOpenCount) )
{
// clear bInitOk, as otherwise collect function
// will attempt to reference into pCounterBlock
bInitOK = FALSE;
if ( pCounterBlock )
{
UnmapViewOfFile( pCounterBlock );
pCounterBlock = NULL;
}
if ( hDnsSharedMemory )
{
CloseHandle( hDnsSharedMemory );
hDnsSharedMemory = NULL;
}
}
return ERROR_SUCCESS;
}
//
// Data for this whole thing to work on
//
DNS_DATA_DEFINITION DnsDataDefinition =
{
// DNS obj for PerfMon:
{ sizeof(DNS_DATA_DEFINITION) + SIZE_OF_DNS_PERFORMANCE_DATA, // TotLen
sizeof(DNS_DATA_DEFINITION), // DefinitionLength
sizeof(PERF_OBJECT_TYPE), // HeaderLength
DNSOBJ, // ObjectNameTitleIndex
0, // ObjectNameTitle
DNSOBJ, // ObjectHelpTitleIndex
0, // ObjectHelpTitle
PERF_DETAIL_NOVICE, // DetailLevel
(sizeof(DNS_DATA_DEFINITION)-sizeof(PERF_OBJECT_TYPE))/
sizeof(PERF_COUNTER_DEFINITION), // NumCounters
0, // DefaultCounter
-1, // NumInstances
0 // CodePage (0=Unicode)
},
// total query received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TOTALQUERYRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
TOTALQUERYRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
TOTALQUERYRECEIVED_OFFSET // CounterOffset
},
// total qurey received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TOTALQUERYRECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
TOTALQUERYRECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
TOTALQUERYRECEIVED_OFFSET // CounterOffset
},
// UDP query received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
UDPQUERYRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
UDPQUERYRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
UDPQUERYRECEIVED_OFFSET // CounterOffset
},
// UDP query received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
UDPQUERYRECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
UDPQUERYRECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
UDPQUERYRECEIVED_OFFSET // CounterOffset
},
// TCP query received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TCPQUERYRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
TCPQUERYRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
TCPQUERYRECEIVED_OFFSET // CounterOffset
},
// TCP query received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TCPQUERYRECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
TCPQUERYRECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
TCPQUERYRECEIVED_OFFSET // CounterOffset
},
// total response sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TOTALRESPONSESENT, // CounterNameTitleIndex
0, // CounterNameTitle
TOTALRESPONSESENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
TOTALRESPONSESENT_OFFSET // CounterOffset
},
// total response sent/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TOTALRESPONSESENT_S, // CounterNameTitleIndex
0, // CounterNameTitle
TOTALRESPONSESENT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
TOTALRESPONSESENT_OFFSET // CounterOffset
},
// UDP response sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
UDPRESPONSESENT, // CounterNameTitleIndex
0, // CounterNameTitle
UDPRESPONSESENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
UDPRESPONSESENT_OFFSET // CounterOffset
},
// UDP response sent/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
UDPRESPONSESENT_S, // CounterNameTitleIndex
0, // CounterNameTitle
UDPRESPONSESENT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
UDPRESPONSESENT_OFFSET // CounterOffset
},
// TCP response sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TCPRESPONSESENT, // CounterNameTitleIndex
0, // CounterNameTitle
TCPRESPONSESENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
TCPRESPONSESENT_OFFSET // CounterOffset
},
// TCP response sent/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TCPRESPONSESENT_S, // CounterNameTitleIndex
0, // CounterNameTitle
TCPRESPONSESENT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
TCPRESPONSESENT_OFFSET // CounterOffset
},
// recursive query received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVEQUERIES, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVEQUERIES, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVEQUERIES_OFFSET // CounterOffset
},
// recursive query received/s
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVEQUERIES_S, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVEQUERIES_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVEQUERIES_OFFSET // CounterOffset
},
// recursive query timeout
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVETIMEOUT, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVETIMEOUT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVETIMEOUT_OFFSET // CounterOffset
},
// recursive query timeout/s
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVETIMEOUT_S, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVETIMEOUT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVETIMEOUT_OFFSET // CounterOffset
},
// recursive query failure
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVEQUERYFAILURE, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVEQUERYFAILURE, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVEQUERYFAILURE_OFFSET // CounterOffset
},
// recursive query failure/s
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECURSIVEQUERYFAILURE_S, // CounterNameTitleIndex
0, // CounterNameTitle
RECURSIVEQUERYFAILURE_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
RECURSIVEQUERYFAILURE_OFFSET // CounterOffset
},
// notify sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
NOTIFYSENT, // CounterNameTitleIndex
0, // CounterNameTitle
NOTIFYSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
NOTIFYSENT_OFFSET // CounterOffset
},
// zone transfer request received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
ZONETRANSFERREQUESTRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
ZONETRANSFERREQUESTRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
ZONETRANSFERREQUESTRECEIVED_OFFSET // CounterOffset
},
// zone transfer success
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
ZONETRANSFERSUCCESS, // CounterNameTitleIndex
0, // CounterNameTitle
ZONETRANSFERSUCCESS, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
ZONETRANSFERSUCCESS_OFFSET // CounterOffset
},
// zone transfer failure
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
ZONETRANSFERFAILURE, // CounterNameTitleIndex
0, // CounterNameTitle
ZONETRANSFERFAILURE, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
ZONETRANSFERFAILURE_OFFSET // CounterOffset
},
// AXFR request received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
AXFRREQUESTRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
AXFRREQUESTRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
AXFRREQUESTRECEIVED_OFFSET // CounterOffset
},
// AXFR success sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
AXFRSUCCESSSENT, // CounterNameTitleIndex
0, // CounterNameTitle
AXFRSUCCESSSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
AXFRSUCCESSSENT_OFFSET // CounterOffset
},
// IXFR request received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRREQUESTRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRREQUESTRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRREQUESTRECEIVED_OFFSET // CounterOffset
},
// IXFR success sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRSUCCESSSENT, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRSUCCESSSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRSUCCESSSENT_OFFSET // CounterOffset
},
// notify received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
NOTIFYRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
NOTIFYRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
NOTIFYRECEIVED_OFFSET // CounterOffset
},
// zone transfer SOA request sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
ZONETRANSFERSOAREQUESTSENT, // CounterNameTitleIndex
0, // CounterNameTitle
ZONETRANSFERSOAREQUESTSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
ZONETRANSFERSOAREQUESTSENT_OFFSET // CounterOffset
},
// AXFR request sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
AXFRREQUESTSENT, // CounterNameTitleIndex
0, // CounterNameTitle
AXFRREQUESTSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
AXFRREQUESTSENT_OFFSET // CounterOffset
},
// AXFR response received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
AXFRRESPONSERECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
AXFRRESPONSERECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
AXFRRESPONSERECEIVED_OFFSET // CounterOffset
},
// AXFR success received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
AXFRSUCCESSRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
AXFRSUCCESSRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
AXFRSUCCESSRECEIVED_OFFSET // CounterOffset
},
// IXFR request sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRREQUESTSENT, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRREQUESTSENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRREQUESTSENT_OFFSET // CounterOffset
},
// IXFR response received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRRESPONSERECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRRESPONSERECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRRESPONSERECEIVED_OFFSET // CounterOffset
},
// IXFR succes received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRSUCCESSRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRSUCCESSRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRSUCCESSRECEIVED_OFFSET // CounterOffset
},
// IXFR UDP success received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRUDPSUCCESSRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRUDPSUCCESSRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRUDPSUCCESSRECEIVED_OFFSET // CounterOffset
},
// IXFR TCP success received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
IXFRTCPSUCCESSRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
IXFRTCPSUCCESSRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
IXFRTCPSUCCESSRECEIVED_OFFSET // CounterOffset
},
// WINS lookup request received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSLOOKUPRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
WINSLOOKUPRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
WINSLOOKUPRECEIVED_OFFSET // CounterOffset
},
// WINS lookup request received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSLOOKUPRECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
WINSLOOKUPRECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
WINSLOOKUPRECEIVED_OFFSET // CounterOffset
},
// WINS response sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSRESPONSESENT, // CounterNameTitleIndex
0, // CounterNameTitle
WINSRESPONSESENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
WINSRESPONSESENT_OFFSET // CounterOffset
},
// WINS response sent/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSRESPONSESENT_S, // CounterNameTitleIndex
0, // CounterNameTitle
WINSRESPONSESENT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
WINSRESPONSESENT_OFFSET // CounterOffset
},
// WINS reverse lookup received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSREVERSELOOKUPRECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
WINSREVERSELOOKUPRECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
WINSREVERSELOOKUPRECEIVED_OFFSET // CounterOffset
},
// WINS reverse lookup received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSREVERSELOOKUPRECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
WINSREVERSELOOKUPRECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
WINSREVERSELOOKUPRECEIVED_OFFSET // CounterOffset
},
// WINS reverse response sent
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSREVERSERESPONSESENT, // CounterNameTitleIndex
0, // CounterNameTitle
WINSREVERSERESPONSESENT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
WINSREVERSERESPONSESENT_OFFSET // CounterOffset
},
// WINS reverse response sent/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
WINSREVERSERESPONSESENT_S, // CounterNameTitleIndex
0, // CounterNameTitle
WINSREVERSERESPONSESENT_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
WINSREVERSERESPONSESENT_OFFSET // CounterOffset
},
// dynamic update received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATERECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATERECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATERECEIVED_OFFSET // CounterOffset
},
// dynamic update received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATERECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATERECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATERECEIVED_OFFSET // CounterOffset
},
// dynamic update NoOperation & Empty
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATENOOP, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATENOOP, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATENOOP_OFFSET // CounterOffset
},
// dynamic update NoOperation & Empty/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATENOOP_S, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATENOOP_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATENOOP_OFFSET // CounterOffset
},
// dynamic update write to database (completed)
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATEWRITETODB, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATEWRITETODB, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATEWRITETODB_OFFSET // CounterOffset
},
// dynamic update write to database (completed)/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATEWRITETODB_S, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATEWRITETODB_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATEWRITETODB_OFFSET // CounterOffset
},
// dynamic update rejected
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATEREJECTED, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATEREJECTED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATEREJECTED_OFFSET // CounterOffset
},
// dynamic update timeout
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATETIMEOUT, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATETIMEOUT, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATETIMEOUT_OFFSET // CounterOffset
},
// dynamic update queued
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DYNAMICUPDATEQUEUED, // CounterNameTitleIndex
0, // CounterNameTitle
DYNAMICUPDATEQUEUED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DYNAMICUPDATEQUEUED_OFFSET // CounterOffset
},
// secure update received
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
SECUREUPDATERECEIVED, // CounterNameTitleIndex
0, // CounterNameTitle
SECUREUPDATERECEIVED, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
SECUREUPDATERECEIVED_OFFSET // CounterOffset
},
// secure update received/sec
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
SECUREUPDATERECEIVED_S, // CounterNameTitleIndex
0, // CounterNameTitle
SECUREUPDATERECEIVED_S, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_COUNTER, // CounterType
sizeof(DWORD), // CounterSize
SECUREUPDATERECEIVED_OFFSET // CounterOffset
},
// secure update failure
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
SECUREUPDATEFAILURE, // CounterNameTitleIndex
0, // CounterNameTitle
SECUREUPDATEFAILURE, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
SECUREUPDATEFAILURE_OFFSET // CounterOffset
},
// database node memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
DATABASENODEMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
DATABASENODEMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
DATABASENODEMEMORY_OFFSET // CounterOffset
},
// record flow memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
RECORDFLOWMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
RECORDFLOWMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
RECORDFLOWMEMORY_OFFSET // CounterOffset
},
// caching memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
CACHINGMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
CACHINGMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
CACHINGMEMORY_OFFSET // CounterOffset
},
// UDP message memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
UDPMESSAGEMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
UDPMESSAGEMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
UDPMESSAGEMEMORY_OFFSET // CounterOffset
},
// TCP message memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
TCPMESSAGEMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
TCPMESSAGEMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
TCPMESSAGEMEMORY_OFFSET // CounterOffset
},
// Nbstat memory
{ sizeof(PERF_COUNTER_DEFINITION), // ByteLength
NBSTATMEMORY, // CounterNameTitleIndex
0, // CounterNameTitle
NBSTATMEMORY, // CounterHelpTitleIndex
0, // CounterHelpTitle
0, // DefaultScale
PERF_DETAIL_NOVICE, // DetailLevel
PERF_COUNTER_RAWCOUNT, // CounterType
sizeof(DWORD), // CounterSize
NBSTATMEMORY_OFFSET // CounterOffset
},
};
int APIENTRY _CRT_INIT(
HANDLE hInstance,
DWORD ulReasonBeingCalled,
LPVOID lpReserved);
int __stdcall LibMain(
HANDLE hInstance,
DWORD ulReasonBeingCalled,
LPVOID lpReserved)
{
return (_CRT_INIT(hInstance, ulReasonBeingCalled,lpReserved));
}
//
// End dnsperf.c
//