mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6289 lines
205 KiB
6289 lines
205 KiB
/*++
|
|
|
|
Copyright (c) 1991-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
lodctr.c
|
|
|
|
Abstract:
|
|
|
|
Program to read the contents of the file specified in the command line
|
|
and update the registry accordingly
|
|
|
|
Author:
|
|
|
|
Bob Watson (a-robw) 10 Feb 93
|
|
|
|
Revision History:
|
|
|
|
a-robw 25-Feb-93 revised calls to make it compile as a UNICODE or
|
|
an ANSI app.
|
|
|
|
Bob Watson (bobw) 10 Mar 99 added event log messages
|
|
|
|
|
|
--*/
|
|
#ifndef UNICODE
|
|
#define UNICODE 1
|
|
#endif
|
|
|
|
#ifndef _UNICODE
|
|
#define _UNICODE 1
|
|
#endif
|
|
|
|
#ifdef _LODCTR_DBG_OUTPUT
|
|
#undef _LODCTR_DBG_OUTPUT
|
|
#endif
|
|
//#define _LODCTR_DBG_OUTPUT
|
|
|
|
//
|
|
// "C" Include files
|
|
//
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <conio.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
//
|
|
// Windows Include files
|
|
//
|
|
#include <windows.h>
|
|
#define __LOADPERF__
|
|
#include <loadperf.h>
|
|
#include <winperf.h>
|
|
#include <tchar.h>
|
|
#include "wmistr.h"
|
|
#include "evntrace.h"
|
|
//
|
|
// application include files
|
|
//
|
|
#include "winperfp.h"
|
|
#include "common.h"
|
|
#include "lodctr.h"
|
|
#include "wbemutil.h"
|
|
#include "mofcomp.h"
|
|
#include "ldprfmsg.h"
|
|
|
|
typedef struct _DllValidationData {
|
|
FILETIME CreationDate;
|
|
LONGLONG FileSize;
|
|
} DllValidationData, *pDllValidationData;
|
|
|
|
#define OLD_VERSION 0x010000
|
|
#define MAX_PROFILE_BUFFER 65536
|
|
|
|
static DWORD dwSystemVersion;
|
|
static DWORD dwFileSize;
|
|
static TCHAR ComputerName[FILE_NAME_BUFFER_SIZE];
|
|
static TCHAR szServiceName[MAX_PATH];
|
|
static TCHAR szServiceDisplayName[MAX_PATH];
|
|
static HKEY hPerfData;
|
|
static BOOL bQuietMode = TRUE; // quiet means no _tprintf's
|
|
|
|
// string constants
|
|
static const TCHAR szDataFileRoot[] = {TEXT("%systemroot%\\system32\\Perf")};
|
|
static const TCHAR szDatExt[] = {TEXT(".DAT")};
|
|
static const TCHAR szBakExt[] = {TEXT(".BAK")};
|
|
static const TCHAR szInfo[] = {TEXT("info")};
|
|
static const TCHAR szDriverName[] = {TEXT("drivername")};
|
|
static const TCHAR szMofFileName[] = {TEXT("MofFile")};
|
|
static const TCHAR szNotFound[] = {TEXT("NotFound")};
|
|
static const TCHAR szLanguages[] = {TEXT("languages")};
|
|
static const TCHAR sz009[] = {TEXT("009")};
|
|
static const TCHAR szSymbolFile[] = {TEXT("symbolfile")};
|
|
static const TCHAR szName[] = {TEXT("_NAME")};
|
|
static const TCHAR szHelp[] = {TEXT("_HELP")};
|
|
static const TCHAR sz_DFormat[] = {TEXT(" %d")};
|
|
static const TCHAR szDFormat[] = {TEXT("%d")};
|
|
static const TCHAR szText[] = {TEXT("text")};
|
|
static const TCHAR szObjects[] = {TEXT("objects")};
|
|
static const TCHAR szSpace[] = {TEXT(" ")};
|
|
static const TCHAR MapFileName[] = {TEXT("Perflib Busy")};
|
|
static const TCHAR szPerflib[] = {TEXT("Perflib")};
|
|
static const TCHAR cszLibrary[] = {TEXT("Library")};
|
|
static const CHAR caszOpen[] = {"Open"};
|
|
static const CHAR caszCollect[] = {"Collect"};
|
|
static const CHAR caszClose[] = {"Close"};
|
|
static const TCHAR szBaseIndex[] = {TEXT("Base Index")};
|
|
static const TCHAR szTrusted[] = {TEXT("Trusted")};
|
|
static const TCHAR szDisablePerformanceCounters[] = {TEXT("Disable Performance Counters")};
|
|
|
|
#define OLD_VERSION 0x010000
|
|
LPCWSTR VersionName = (LPCWSTR)L"Version";
|
|
LPCWSTR CounterName = (LPCWSTR)L"Counter ";
|
|
LPCWSTR HelpName = (LPCWSTR)L"Explain ";
|
|
|
|
int __cdecl
|
|
My_vfwprintf(
|
|
FILE *str,
|
|
const wchar_t *format,
|
|
va_list argptr
|
|
);
|
|
|
|
__inline
|
|
void __cdecl
|
|
OUTPUT_MESSAGE (
|
|
const TCHAR* format,
|
|
...
|
|
)
|
|
{
|
|
va_list args;
|
|
va_start( args, format );
|
|
|
|
if (!bQuietMode) {
|
|
My_vfwprintf(stdout, format, args);
|
|
}
|
|
|
|
va_end(args);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
PPERF_OBJECT_TYPE
|
|
NextObject (
|
|
PPERF_OBJECT_TYPE pObject
|
|
)
|
|
{ // NextObject
|
|
return ((PPERF_OBJECT_TYPE) ((PBYTE) pObject + pObject->TotalByteLength));
|
|
} // NextObject
|
|
|
|
__inline
|
|
static
|
|
PERF_COUNTER_DEFINITION *
|
|
FirstCounter(
|
|
PERF_OBJECT_TYPE *pObjectDef
|
|
)
|
|
{
|
|
return (PERF_COUNTER_DEFINITION *)
|
|
((PCHAR) pObjectDef + pObjectDef->HeaderLength);
|
|
}
|
|
|
|
__inline
|
|
static
|
|
PERF_COUNTER_DEFINITION *
|
|
NextCounter(
|
|
PERF_COUNTER_DEFINITION *pCounterDef
|
|
)
|
|
{
|
|
return (PERF_COUNTER_DEFINITION *)
|
|
((PCHAR) pCounterDef + pCounterDef->ByteLength);
|
|
}
|
|
|
|
DWORD
|
|
MakeTempFileName (
|
|
LPCWSTR wszRoot,
|
|
LPWSTR wszTempFilename
|
|
)
|
|
{
|
|
FILETIME ft;
|
|
DWORD dwReturn;
|
|
WCHAR wszLocalFilename[MAX_PATH];
|
|
|
|
GetSystemTimeAsFileTime (&ft);
|
|
dwReturn = (DWORD) swprintf(wszLocalFilename,
|
|
(LPCWSTR)L"%%windir%%\\system32\\wbem\\%s_%8.8x%8.8x.mof",
|
|
(wszRoot != NULL ? wszRoot : (LPCWSTR)L"LodCtr"),
|
|
ft.dwHighDateTime, ft.dwLowDateTime);
|
|
if (dwReturn > 0) {
|
|
// expand env. vars
|
|
dwReturn = ExpandEnvironmentStringsW (
|
|
wszLocalFilename,
|
|
wszTempFilename,
|
|
MAX_PATH-1);
|
|
}
|
|
return dwReturn;
|
|
}
|
|
|
|
DWORD
|
|
WriteWideStringToAnsiFile (
|
|
HANDLE hFile,
|
|
LPCWSTR szWideString,
|
|
LPDWORD pdwLength
|
|
)
|
|
{
|
|
BOOL bStatus;
|
|
DWORD dwStatus;
|
|
LPSTR szAnsiString;
|
|
DWORD dwBytesWritten = 0;
|
|
|
|
szAnsiString = MemoryAllocate(* pdwLength);
|
|
if (szAnsiString != NULL) {
|
|
wcstombs (szAnsiString, szWideString, *pdwLength);
|
|
bStatus = WriteFile (
|
|
hFile,
|
|
(LPCVOID) szAnsiString,
|
|
*pdwLength,
|
|
&dwBytesWritten,
|
|
NULL);
|
|
|
|
if (bStatus) {
|
|
*pdwLength = dwBytesWritten;
|
|
dwStatus = ERROR_SUCCESS;
|
|
} else {
|
|
dwStatus = GetLastError();
|
|
}
|
|
MemoryFree (szAnsiString);
|
|
} else {
|
|
dwStatus = GetLastError();
|
|
}
|
|
return dwStatus;
|
|
}
|
|
|
|
LPWSTR
|
|
*BuildNameTable(
|
|
HKEY hKeyRegistry, // handle to registry db with counter names
|
|
LPWSTR lpszLangId, // unicode value of Language subkey
|
|
PDWORD pdwLastItem // size of array in elements
|
|
)
|
|
/*++
|
|
|
|
BuildNameTable
|
|
|
|
Arguments:
|
|
|
|
hKeyRegistry
|
|
Handle to an open registry (this can be local or remote.) and
|
|
is the value returned by RegConnectRegistry or a default key.
|
|
|
|
lpszLangId
|
|
The unicode id of the language to look up. (default is 409)
|
|
|
|
Return Value:
|
|
|
|
pointer to an allocated table. (the caller must MemoryFree it when finished!)
|
|
the table is an array of pointers to zero terminated strings. NULL is
|
|
returned if an error occured.
|
|
|
|
--*/
|
|
{
|
|
|
|
LPWSTR *lpReturnValue;
|
|
|
|
LPWSTR *lpCounterId;
|
|
LPWSTR lpCounterNames;
|
|
LPWSTR lpHelpText;
|
|
|
|
LPWSTR lpThisName;
|
|
|
|
LONG lWin32Status;
|
|
DWORD dwLastError;
|
|
DWORD dwValueType;
|
|
DWORD dwArraySize;
|
|
DWORD dwBufferSize;
|
|
DWORD dwCounterSize;
|
|
DWORD dwHelpSize;
|
|
DWORD dwThisCounter;
|
|
|
|
DWORD dwSystemVersion;
|
|
DWORD dwLastId;
|
|
DWORD dwLastHelpId;
|
|
DWORD dwLastCounterId;
|
|
|
|
DWORD dwLastCounterIdUsed;
|
|
DWORD dwLastHelpIdUsed;
|
|
|
|
HKEY hKeyValue;
|
|
HKEY hKeyNames;
|
|
|
|
LPWSTR lpValueNameString;
|
|
WCHAR CounterNameBuffer [50];
|
|
WCHAR HelpNameBuffer [50];
|
|
|
|
lpValueNameString = NULL; //initialize to NULL
|
|
lpReturnValue = NULL;
|
|
hKeyValue = NULL;
|
|
hKeyNames = NULL;
|
|
|
|
// check for null arguments and insert defaults if necessary
|
|
|
|
if (!lpszLangId) {
|
|
lpszLangId = (LPWSTR)DefaultLangId;
|
|
}
|
|
|
|
// open registry to get number of items for computing array size
|
|
|
|
__try {
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
NamesKey,
|
|
RESERVED,
|
|
KEY_READ,
|
|
& hKeyValue);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_OPEN_KEY, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) NamesKey, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(NamesKey),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastHelpId);
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
LastHelp,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwLastHelpId,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_VALUE, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) LastHelp, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(LastHelp),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
// get number of items
|
|
|
|
dwBufferSize = sizeof (dwLastId);
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
LastCounter,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwLastCounterId,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_VALUE, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) LastCounter, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(LastCounter),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwLastId = (dwLastCounterId < dwLastHelpId)
|
|
? (dwLastHelpId) : (dwLastCounterId);
|
|
|
|
// compute size of pointer array
|
|
dwArraySize = (dwLastId + 1) * sizeof(LPWSTR);
|
|
|
|
// get Perflib system version
|
|
dwBufferSize = sizeof (dwSystemVersion);
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyValue,
|
|
VersionName,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPBYTE) & dwSystemVersion,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if ((lWin32Status != ERROR_SUCCESS) || (dwValueType != REG_DWORD)) {
|
|
dwSystemVersion = OLD_VERSION;
|
|
// reset the error status
|
|
lWin32Status = ERROR_SUCCESS;
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
0,
|
|
lWin32Status,
|
|
TRACE_DWORD(dwLastCounterId),
|
|
TRACE_DWORD(dwLastHelpId),
|
|
NULL));
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// get names from registry
|
|
lpValueNameString = MemoryAllocate (
|
|
lstrlen(NamesKey) * sizeof (WCHAR) +
|
|
lstrlen(Slash) * sizeof (WCHAR) +
|
|
lstrlen(lpszLangId) * sizeof (WCHAR) +
|
|
sizeof (UNICODE_NULL));
|
|
|
|
if (!lpValueNameString) goto BNT_BAILOUT;
|
|
|
|
lstrcpy (lpValueNameString, NamesKey);
|
|
lstrcat (lpValueNameString, Slash);
|
|
lstrcat (lpValueNameString, lpszLangId);
|
|
|
|
lWin32Status = RegOpenKeyEx (
|
|
hKeyRegistry,
|
|
lpValueNameString,
|
|
RESERVED,
|
|
KEY_READ,
|
|
& hKeyNames);
|
|
} else {
|
|
if (ComputerName[0] == 0) {
|
|
hKeyNames = HKEY_PERFORMANCE_DATA;
|
|
} else {
|
|
__try {
|
|
lWin32Status = RegConnectRegistry(ComputerName,
|
|
HKEY_PERFORMANCE_DATA,
|
|
& hKeyNames);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
}
|
|
lstrcpy (CounterNameBuffer, CounterName);
|
|
lstrcat (CounterNameBuffer, lpszLangId);
|
|
|
|
lstrcpy (HelpNameBuffer, HelpName);
|
|
lstrcat (HelpNameBuffer, lpszLangId);
|
|
}
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_ACCESS_STRINGS, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpszLangId, NULL, NULL);
|
|
goto BNT_BAILOUT;
|
|
}
|
|
dwBufferSize = 0;
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_COUNTER_STRINGS, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpszLangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(Counters),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwCounterSize = dwBufferSize;
|
|
|
|
// get size of counter names and add that to the arrays
|
|
|
|
if (lWin32Status != ERROR_SUCCESS) goto BNT_BAILOUT;
|
|
|
|
dwBufferSize = 0;
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_HELP_STRINGS, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpszLangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(Help),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwHelpSize = dwBufferSize;
|
|
|
|
lpReturnValue = MemoryAllocate (dwArraySize + dwCounterSize + dwHelpSize);
|
|
|
|
if (!lpReturnValue) {
|
|
lWin32Status = ERROR_OUTOFMEMORY;
|
|
SetLastError(lWin32Status);
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_MEMORY_ALLOCATION_FAILURE, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
0, NULL, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
0,
|
|
ERROR_OUTOFMEMORY,
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
// initialize pointers into buffer
|
|
|
|
lpCounterId = lpReturnValue;
|
|
lpCounterNames = (LPWSTR)((LPBYTE)lpCounterId + dwArraySize);
|
|
lpHelpText = (LPWSTR)((LPBYTE)lpCounterNames + dwCounterSize);
|
|
|
|
// read counters into memory
|
|
|
|
dwBufferSize = dwCounterSize;
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) lpCounterNames,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_COUNTER_STRINGS, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpszLangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(Counters),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwBufferSize = dwHelpSize;
|
|
__try {
|
|
lWin32Status = RegQueryValueEx (
|
|
hKeyNames,
|
|
dwSystemVersion == OLD_VERSION ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) lpHelpText,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lWin32Status = GetExceptionCode();
|
|
}
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_HELP_STRINGS, // event,
|
|
2, lWin32Status, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpszLangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(Help),
|
|
NULL));
|
|
goto BNT_BAILOUT;
|
|
}
|
|
|
|
dwLastCounterIdUsed = 0;
|
|
dwLastHelpIdUsed = 0;
|
|
|
|
// load counter array items
|
|
|
|
for (lpThisName = lpCounterNames;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if ((dwThisCounter == 0) || (dwThisCounter > dwLastId)) {
|
|
lWin32Status = ERROR_INVALID_DATA;
|
|
SetLastError(lWin32Status);
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_COUNTER_STRINGS_CORRUPT, // event,
|
|
4, dwThisCounter, dwLastCounterId, dwLastId, __LINE__,
|
|
1, lpThisName, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(lpThisName),
|
|
TRACE_DWORD(dwThisCounter),
|
|
TRACE_DWORD(dwLastId),
|
|
NULL));
|
|
goto BNT_BAILOUT; // bad entry
|
|
}
|
|
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
if (dwThisCounter > dwLastCounterIdUsed) dwLastCounterIdUsed = dwThisCounter;
|
|
|
|
}
|
|
|
|
for (lpThisName = lpHelpText;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
|
|
if ((dwThisCounter == 0) || (dwThisCounter > dwLastId)) {
|
|
lWin32Status = ERROR_INVALID_DATA;
|
|
SetLastError(lWin32Status);
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_HELP_STRINGS_CORRUPT, // event,
|
|
4, dwThisCounter, dwLastHelpId, dwLastId, __LINE__,
|
|
1, lpThisName, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(lpThisName),
|
|
TRACE_DWORD(dwThisCounter),
|
|
TRACE_DWORD(dwLastId),
|
|
NULL));
|
|
goto BNT_BAILOUT; // bad entry
|
|
}
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
lpCounterId[dwThisCounter] = lpThisName;
|
|
|
|
if (dwThisCounter > dwLastHelpIdUsed) dwLastHelpIdUsed= dwThisCounter;
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LODCTR_BUILDNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lWin32Status,
|
|
TRACE_WSTR(lpszLangId),
|
|
TRACE_DWORD(dwLastCounterIdUsed),
|
|
TRACE_DWORD(dwLastHelpIdUsed),
|
|
TRACE_DWORD(dwLastId),
|
|
NULL));
|
|
|
|
// check the registry for consistency
|
|
// the last help string index should be the last ID used
|
|
if (dwLastCounterIdUsed > dwLastId) {
|
|
lWin32Status = ERROR_INVALID_DATA;
|
|
SetLastError(lWin32Status);
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_INDEX_CORRUPT, // event,
|
|
3, dwLastId, dwLastCounterIdUsed, __LINE__, 0,
|
|
0, NULL, NULL, NULL);
|
|
goto BNT_BAILOUT; // bad registry
|
|
}
|
|
if (dwLastHelpIdUsed > dwLastId) {
|
|
lWin32Status = ERROR_INVALID_DATA;
|
|
SetLastError(lWin32Status);
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_INDEX_CORRUPT, // event,
|
|
3, dwLastId, dwLastHelpIdUsed, __LINE__, 0,
|
|
0, NULL, NULL, NULL);
|
|
goto BNT_BAILOUT; // bad registry
|
|
}
|
|
|
|
if (pdwLastItem) *pdwLastItem = dwLastId;
|
|
|
|
MemoryFree ((LPVOID)lpValueNameString);
|
|
if (hKeyValue) {
|
|
RegCloseKey (hKeyValue);
|
|
}
|
|
if (hKeyNames && hKeyNames != HKEY_PERFORMANCE_DATA) {
|
|
RegCloseKey (hKeyNames);
|
|
}
|
|
|
|
return lpReturnValue;
|
|
|
|
BNT_BAILOUT:
|
|
if (lWin32Status != ERROR_SUCCESS) {
|
|
dwLastError = GetLastError();
|
|
}
|
|
if (lpValueNameString) {
|
|
MemoryFree ((LPVOID)lpValueNameString);
|
|
}
|
|
if (lpReturnValue) {
|
|
MemoryFree ((LPVOID)lpReturnValue);
|
|
}
|
|
|
|
if (hKeyValue) {
|
|
RegCloseKey (hKeyValue);
|
|
}
|
|
if (hKeyNames && hKeyNames != HKEY_PERFORMANCE_DATA) {
|
|
RegCloseKey (hKeyNames);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
MakeBackupCopyOfLanguageFiles (
|
|
IN LPCTSTR szLangId
|
|
)
|
|
{
|
|
TCHAR szOldFileName[MAX_PATH];
|
|
TCHAR szTmpFileName[MAX_PATH];
|
|
TCHAR szNewFileName[MAX_PATH];
|
|
|
|
BOOL bStatus;
|
|
|
|
DWORD dwStatus;
|
|
HANDLE hOutFile;
|
|
|
|
UNREFERENCED_PARAMETER (szLangId);
|
|
|
|
ExpandEnvironmentStrings (szDataFileRoot, szOldFileName, MAX_PATH);
|
|
_stprintf (szNewFileName, (LPCTSTR)(TEXT("%sStringBackup.INI")), szOldFileName);
|
|
_stprintf(szTmpFileName,
|
|
(LPCTSTR)(TEXT("%sStringBackup.TMP")),
|
|
szOldFileName);
|
|
|
|
// see if the file already exists
|
|
hOutFile = CreateFile(
|
|
szTmpFileName,
|
|
GENERIC_READ,
|
|
0, // no sharing
|
|
NULL, // default security
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if (hOutFile != INVALID_HANDLE_VALUE) {
|
|
CloseHandle(hOutFile);
|
|
bStatus = DeleteFile(szTmpFileName);
|
|
}
|
|
|
|
// create backup of file
|
|
//
|
|
dwStatus = BackupPerfRegistryToFileW (szTmpFileName, NULL);
|
|
if (dwStatus == ERROR_SUCCESS) {
|
|
bStatus = CopyFile(szTmpFileName, szNewFileName, FALSE);
|
|
if (bStatus) {
|
|
DeleteFile(szTmpFileName);
|
|
}
|
|
} else {
|
|
// unable to create a backup file
|
|
SetLastError (dwStatus);
|
|
bStatus = FALSE;
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_MAKEBACKUPCOPYOFLANGUAGEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
GetLastError(),
|
|
TRACE_WSTR(szNewFileName),
|
|
NULL));
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
GetFileFromCommandLine (
|
|
IN LPTSTR lpCommandLine,
|
|
OUT LPTSTR *lpFileName,
|
|
IN DWORD_PTR *pdwFlags
|
|
)
|
|
/*++
|
|
|
|
GetFileFromCommandLine
|
|
|
|
parses the command line to retrieve the ini filename that should be
|
|
the first and only argument.
|
|
|
|
Arguments
|
|
|
|
lpCommandLine pointer to command line (returned by GetCommandLine)
|
|
lpFileName pointer to buffer that will recieve address of the
|
|
validated filename entered on the command line
|
|
pdwFlags pointer to dword containing flag bits
|
|
|
|
Return Value
|
|
|
|
TRUE if a valid filename was returned
|
|
FALSE if the filename is not valid or missing
|
|
error is returned in GetLastError
|
|
|
|
--*/
|
|
{
|
|
INT iNumArgs;
|
|
|
|
LPTSTR lpExeName = NULL;
|
|
LPTSTR lpCmdLineName = NULL;
|
|
LPWSTR lpIniFileName = NULL;
|
|
LPWSTR lpMofFlag = NULL;
|
|
HANDLE hFileHandle;
|
|
TCHAR LocalComputerName[FILE_NAME_BUFFER_SIZE];
|
|
DWORD NameBuffer;
|
|
|
|
DWORD dwCpuArg, dwIniArg;
|
|
|
|
// check for valid arguments
|
|
|
|
if (!lpCommandLine) return (ERROR_INVALID_PARAMETER);
|
|
if (!lpFileName) return (ERROR_INVALID_PARAMETER);
|
|
if (!pdwFlags) return (ERROR_INVALID_PARAMETER);
|
|
|
|
// allocate memory for parsing operation
|
|
|
|
lpExeName = MemoryAllocate (FILE_NAME_BUFFER_SIZE * sizeof(TCHAR));
|
|
lpCmdLineName = MemoryAllocate (FILE_NAME_BUFFER_SIZE * sizeof(TCHAR));
|
|
lpIniFileName = MemoryAllocate (FILE_NAME_BUFFER_SIZE * sizeof(WCHAR));
|
|
lpMofFlag = MemoryAllocate (FILE_NAME_BUFFER_SIZE * sizeof(WCHAR));
|
|
|
|
if (!lpExeName || !lpIniFileName || !lpCmdLineName || !lpMofFlag) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
if (lpCmdLineName) MemoryFree (lpCmdLineName);
|
|
if (lpMofFlag) MemoryFree (lpMofFlag);
|
|
return FALSE;
|
|
} else {
|
|
// get strings from command line
|
|
RtlZeroMemory(ComputerName, sizeof(TCHAR) * FILE_NAME_BUFFER_SIZE);
|
|
RtlZeroMemory(LocalComputerName, sizeof(TCHAR) * FILE_NAME_BUFFER_SIZE);
|
|
|
|
// check for mof Flag
|
|
lstrcpyW (lpMofFlag, GetItemFromString (lpCommandLine, 2, cSpace));
|
|
|
|
*pdwFlags |= LOADPERF_FLAGS_LOAD_REGISTRY_ONLY; // default unless a switch is found
|
|
|
|
if ((lpMofFlag[0] == cHyphen) || (lpMofFlag[0] == cSlash)) {
|
|
if ((lpMofFlag[1] == cM) || (lpMofFlag[1] == cm)) {
|
|
*pdwFlags &= ~LOADPERF_FLAGS_LOAD_REGISTRY_ONLY; // clear that bit
|
|
} else if ((lpMofFlag[1] == cQuestion)) {
|
|
// ask for usage
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
if (lpMofFlag) MemoryFree (lpMofFlag);
|
|
return FALSE;
|
|
}
|
|
dwCpuArg = 3;
|
|
dwIniArg = 4;
|
|
} else {
|
|
dwCpuArg = 2;
|
|
dwIniArg = 3;
|
|
}
|
|
|
|
// Get INI File name
|
|
|
|
lstrcpy (lpCmdLineName, GetItemFromString (lpCommandLine, dwIniArg, cSpace));
|
|
if (lstrlen(lpCmdLineName) == 0) {
|
|
// then no computer name was specified so try to get the
|
|
// ini file from the 2nd entry
|
|
lstrcpy (lpCmdLineName, GetItemFromString (lpCommandLine, dwCpuArg, cSpace));
|
|
if (lstrlen(lpCmdLineName) == 0) {
|
|
// no ini file found
|
|
iNumArgs = 1;
|
|
} else {
|
|
// fill in a blank computer name
|
|
iNumArgs = 2;
|
|
ComputerName[0] = 0;
|
|
}
|
|
} else {
|
|
// the computer name must be present so fetch it
|
|
lstrcpy (LocalComputerName, GetItemFromString (lpCommandLine, dwCpuArg, cSpace));
|
|
iNumArgs = 3;
|
|
}
|
|
|
|
if (iNumArgs != 2 && iNumArgs != 3) {
|
|
// wrong number of arguments
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
if (lpMofFlag) MemoryFree (lpMofFlag);
|
|
return FALSE;
|
|
} else {
|
|
// check if there is a computer name in the input line
|
|
if (LocalComputerName[0] == cBackslash &&
|
|
LocalComputerName[1] == cBackslash) {
|
|
// save it form now
|
|
lstrcpy (ComputerName, LocalComputerName);
|
|
// reuse local buffer to get the this computer's name
|
|
NameBuffer = sizeof (LocalComputerName) / sizeof (TCHAR);
|
|
GetComputerName(LocalComputerName, &NameBuffer);
|
|
if (!lstrcmpi(LocalComputerName, &ComputerName[2])) {
|
|
// same name as local computer name
|
|
// so clear computer name buffer
|
|
ComputerName[0] = 0;
|
|
}
|
|
}
|
|
|
|
if (SearchPath (NULL, lpCmdLineName,
|
|
NULL, FILE_NAME_BUFFER_SIZE,
|
|
lpIniFileName, NULL) > 0) {
|
|
|
|
hFileHandle = CreateFile (
|
|
lpIniFileName,
|
|
GENERIC_READ,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
MemoryFree (lpCmdLineName);
|
|
|
|
if (hFileHandle && hFileHandle != INVALID_HANDLE_VALUE) {
|
|
// get file size
|
|
dwFileSize = GetFileSize (hFileHandle, NULL);
|
|
if (dwFileSize == 0xffffffff) {
|
|
dwFileSize = 0L;
|
|
} else {
|
|
dwFileSize *= sizeof (TCHAR);
|
|
}
|
|
|
|
CloseHandle (hFileHandle);
|
|
|
|
// file exists, so return name and success
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
|
|
lstrcpyW (*lpFileName, lpIniFileName);
|
|
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
return TRUE;
|
|
} else {
|
|
// filename was on command line, but not valid so return
|
|
// false, but send name back for error message
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
lstrcpyW (*lpFileName, lpIniFileName);
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
MemoryFree (lpCmdLineName);
|
|
SetLastError (ERROR_OPEN_FAILED);
|
|
if (lpExeName) MemoryFree (lpExeName);
|
|
if (lpIniFileName) MemoryFree (lpIniFileName);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
LodctrSetSericeAsTrusted(
|
|
IN LPCTSTR lpIniFile,
|
|
IN LPCTSTR szMachineName,
|
|
IN LPCTSTR szServiceName
|
|
)
|
|
/*++
|
|
GetDriverName
|
|
|
|
looks up driver name in the .ini file and returns it in lpDevName
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
|
|
Filename of ini file
|
|
|
|
lpDevName
|
|
|
|
pointer to pointer to reciev buffer w/dev name in it
|
|
|
|
Return Value
|
|
|
|
TRUE if found
|
|
FALSE if not found in .ini file
|
|
|
|
--*/
|
|
{
|
|
DWORD dwRetSize;
|
|
DWORD dwStatus;
|
|
BOOL bReturn;
|
|
static WCHAR szParam[MAX_PATH];
|
|
|
|
dwRetSize = GetPrivateProfileString (
|
|
szInfo, // info section
|
|
szTrusted, // Trusted name value
|
|
szNotFound, // default value
|
|
szParam,
|
|
MAX_PATH,
|
|
lpIniFile);
|
|
|
|
if ((lstrcmpi(szParam, szNotFound)) != 0) {
|
|
// Trusted string found so set
|
|
dwStatus = SetServiceAsTrustedW (
|
|
szMachineName,
|
|
szServiceName);
|
|
if (dwStatus != ERROR_SUCCESS) {
|
|
SetLastError (dwStatus);
|
|
bReturn = FALSE;
|
|
}
|
|
bReturn = TRUE;
|
|
} else {
|
|
// Service is not trusted to have a good Perf DLL
|
|
SetLastError (ERROR_SUCCESS);
|
|
bReturn = FALSE;
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
GetDriverName (
|
|
IN LPTSTR lpIniFile,
|
|
OUT LPTSTR *lpDevName
|
|
)
|
|
/*++
|
|
GetDriverName
|
|
|
|
looks up driver name in the .ini file and returns it in lpDevName
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
|
|
Filename of ini file
|
|
|
|
lpDevName
|
|
|
|
pointer to pointer to reciev buffer w/dev name in it
|
|
|
|
Return Value
|
|
|
|
TRUE if found
|
|
FALSE if not found in .ini file
|
|
|
|
--*/
|
|
{
|
|
DWORD dwRetSize;
|
|
BOOL bReturn = FALSE;
|
|
|
|
if (lpDevName) {
|
|
dwRetSize = GetPrivateProfileString (
|
|
szInfo, // info section
|
|
szDriverName, // driver name value
|
|
szNotFound, // default value
|
|
* lpDevName,
|
|
MAX_PATH,
|
|
lpIniFile);
|
|
|
|
if ((lstrcmpi(*lpDevName, szNotFound)) != 0) {
|
|
// name found
|
|
bReturn = TRUE;
|
|
} else {
|
|
// name not found, default returned so return NULL string
|
|
SetLastError (ERROR_BAD_DRIVER);
|
|
*lpDevName = 0;
|
|
}
|
|
} else {
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_GETDRIVERNAME,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
GetLastError(),
|
|
TRACE_WSTR(lpIniFile),
|
|
NULL));
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
BuildLanguageTables (
|
|
IN LPTSTR lpIniFile,
|
|
IN OUT PLANGUAGE_LIST_ELEMENT pFirstElem
|
|
)
|
|
/*++
|
|
|
|
BuildLanguageTables
|
|
|
|
Creates a list of structures that will hold the text for
|
|
each supported language
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
|
|
Filename with data
|
|
|
|
pFirstElem
|
|
|
|
pointer to first list entry
|
|
|
|
ReturnValue
|
|
|
|
TRUE if all OK
|
|
FALSE if not
|
|
|
|
--*/
|
|
{
|
|
|
|
LPTSTR lpEnumeratedLangs = NULL;
|
|
LPTSTR lpThisLang = NULL;
|
|
PLANGUAGE_LIST_ELEMENT pThisElem;
|
|
PLANGUAGE_LIST_ELEMENT pPrevElem;
|
|
DWORD dwSize;
|
|
BOOL bReturn = FALSE;
|
|
|
|
if (lpIniFile == NULL || pFirstElem == NULL) {
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
lpEnumeratedLangs = MemoryAllocate(SMALL_BUFFER_SIZE * sizeof(TCHAR));
|
|
|
|
if (!lpEnumeratedLangs) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwSize = GetPrivateProfileString (
|
|
szLanguages,
|
|
NULL, // return all values in multi-sz string
|
|
sz009, // english as the default
|
|
lpEnumeratedLangs,
|
|
SMALL_BUFFER_SIZE,
|
|
lpIniFile);
|
|
|
|
// do first language
|
|
|
|
lpThisLang = lpEnumeratedLangs;
|
|
pThisElem = NULL;
|
|
pPrevElem = NULL;
|
|
|
|
while (*lpThisLang) {
|
|
//
|
|
// see if this language is supporte on this machine
|
|
//
|
|
if (pThisElem == NULL) {
|
|
pThisElem = pPrevElem = pFirstElem;
|
|
} else {
|
|
pThisElem->pNextLang = MemoryAllocate (sizeof(LANGUAGE_LIST_ELEMENT));
|
|
if (!pThisElem->pNextLang) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
goto Cleanup;
|
|
}
|
|
pPrevElem = pThisElem;
|
|
pThisElem = pThisElem->pNextLang; // point to new one
|
|
}
|
|
pThisElem->pNextLang = NULL;
|
|
pThisElem->LangId = (LPTSTR) MemoryAllocate ((lstrlen(lpThisLang) + 1) * sizeof(TCHAR));
|
|
if (pThisElem->LangId == NULL) {
|
|
if (pThisElem == pFirstElem) {
|
|
pThisElem = pPrevElem = NULL;
|
|
}
|
|
else {
|
|
MemoryFree(pThisElem);
|
|
pThisElem = pPrevElem;
|
|
pThisElem->pNextLang = NULL;
|
|
}
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
goto Cleanup;
|
|
}
|
|
lstrcpy (pThisElem->LangId, lpThisLang);
|
|
pThisElem->pFirstName = NULL;
|
|
pThisElem->pThisName = NULL;
|
|
pThisElem->dwNumElements=0;
|
|
pThisElem->NameBuffer = NULL;
|
|
pThisElem->HelpBuffer = NULL;
|
|
pThisElem->dwNameBuffSize = 0;
|
|
pThisElem->dwHelpBuffSize = 0;
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_BUILDLANGUAGETABLES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(pThisElem->LangId),
|
|
NULL));
|
|
|
|
// go to next string
|
|
|
|
lpThisLang += lstrlen(lpThisLang) + 1;
|
|
}
|
|
|
|
if (pThisElem == NULL) {
|
|
// then no languages were found
|
|
SetLastError (ERROR_RESOURCE_LANG_NOT_FOUND);
|
|
} else {
|
|
bReturn = TRUE;
|
|
}
|
|
|
|
Cleanup:
|
|
if (! bReturn) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_BUILDLANGUAGETABLES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
GetLastError(),
|
|
TRACE_WSTR(lpThisLang),
|
|
NULL));
|
|
}
|
|
if (lpEnumeratedLangs != NULL) {
|
|
MemoryFree(lpEnumeratedLangs);
|
|
}
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
LoadIncludeFile (
|
|
IN LPTSTR lpIniFile,
|
|
OUT PSYMBOL_TABLE_ENTRY *pTable
|
|
)
|
|
/*++
|
|
|
|
LoadIncludeFile
|
|
|
|
Reads the include file that contains symbolic name definitions and
|
|
loads a table with the values defined
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
|
|
Ini file with include file name
|
|
|
|
pTable
|
|
|
|
address of pointer to table structure created
|
|
Return Value
|
|
|
|
TRUE if table read or if no table defined
|
|
FALSE if error encountere reading table
|
|
|
|
--*/
|
|
{
|
|
INT iNumArgs;
|
|
DWORD dwSize;
|
|
BOOL bReUse;
|
|
PSYMBOL_TABLE_ENTRY pThisSymbol = NULL;
|
|
LPTSTR lpIncludeFileName = NULL;
|
|
LPTSTR lpIncludeFile = NULL;
|
|
LPTSTR lpIniPath = NULL;
|
|
LPSTR lpLineBuffer = NULL;
|
|
LPSTR lpAnsiSymbol = NULL;
|
|
TCHAR szIniDrive[_MAX_DRIVE];
|
|
TCHAR szIniDir[_MAX_DIR];
|
|
FILE * fIncludeFile = NULL;
|
|
DWORD dwLen;
|
|
BOOL bReturn = TRUE;
|
|
|
|
lpIncludeFileName = MemoryAllocate (MAX_PATH * sizeof (TCHAR));
|
|
lpIncludeFile = MemoryAllocate (MAX_PATH * sizeof(TCHAR));
|
|
lpLineBuffer = MemoryAllocate (DISP_BUFF_SIZE);
|
|
lpAnsiSymbol = MemoryAllocate (DISP_BUFF_SIZE);
|
|
lpIniPath = MemoryAllocate (MAX_PATH * sizeof (TCHAR));
|
|
|
|
if (!lpIncludeFileName || !lpLineBuffer || !lpAnsiSymbol || !lpIniPath) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_MEMORY_ALLOCATION_FAILURE, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
0, NULL, NULL, NULL);
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// get name of include file (if present)
|
|
|
|
dwSize = GetPrivateProfileString (
|
|
szInfo,
|
|
szSymbolFile,
|
|
szNotFound,
|
|
lpIncludeFileName,
|
|
MAX_PATH,
|
|
lpIniFile);
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADINCLUDEFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(lpIncludeFileName),
|
|
NULL));
|
|
|
|
if (lstrcmpi(lpIncludeFileName, szNotFound) == 0) {
|
|
// no symbol file defined
|
|
* pTable = NULL;
|
|
bReturn = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// if here, then a symbol file was defined and is now stored in
|
|
// lpIncludeFileName
|
|
|
|
// get path for the ini file and search that first
|
|
|
|
_tsplitpath (lpIniFile, szIniDrive, szIniDir, NULL, NULL);
|
|
lpIniPath = lstrcpy (lpIniPath, szIniDrive);
|
|
lpIniPath = lstrcat (lpIniPath, szIniDir);
|
|
|
|
dwLen = SearchPath(lpIniPath, lpIncludeFileName, NULL,
|
|
MAX_PATH, lpIncludeFile, NULL);
|
|
if (dwLen == 0) {
|
|
// include file not found with the ini file so search the std. path
|
|
dwLen = SearchPath(NULL, lpIncludeFileName, NULL,
|
|
MAX_PATH, lpIncludeFile, NULL);
|
|
}
|
|
|
|
if (dwLen > 0) {
|
|
|
|
// file name expanded and found so open
|
|
fIncludeFile = _tfopen (lpIncludeFile, (LPCTSTR)TEXT("rt"));
|
|
|
|
if (fIncludeFile == NULL) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_OPEN_INCLUDE), lpIncludeFileName);
|
|
*pTable = NULL;
|
|
SetLastError (ERROR_OPEN_FAILED);
|
|
bReturn = FALSE;
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADINCLUDEFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_OPEN_FAILED,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(lpIncludeFile),
|
|
NULL));
|
|
goto Cleanup;
|
|
}
|
|
} else {
|
|
// unable to find the include filename
|
|
// error is already in GetLastError
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_OPEN_INCLUDE), lpIncludeFileName);
|
|
*pTable = NULL;
|
|
SetLastError (ERROR_BAD_PATHNAME);
|
|
bReturn = FALSE;
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADINCLUDEFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_BAD_PATHNAME,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(lpIncludeFileName),
|
|
NULL));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// read ANSI Characters from include file
|
|
//
|
|
|
|
bReUse = FALSE;
|
|
|
|
while (fgets(lpLineBuffer, DISP_BUFF_SIZE, fIncludeFile) != NULL) {
|
|
if (strlen(lpLineBuffer) > 8) {
|
|
if (!bReUse) {
|
|
if (*pTable) {
|
|
// then add to list
|
|
pThisSymbol->pNext = MemoryAllocate (sizeof (SYMBOL_TABLE_ENTRY));
|
|
pThisSymbol = pThisSymbol->pNext;
|
|
} else { // allocate first element
|
|
*pTable = MemoryAllocate (sizeof (SYMBOL_TABLE_ENTRY));
|
|
pThisSymbol = *pTable;
|
|
}
|
|
|
|
if (!pThisSymbol) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// allocate room for the symbol name by using the line length
|
|
// - the size of "#define "
|
|
|
|
// pThisSymbol->SymbolName = MemoryAllocate ((strlen(lpLineBuffer) - 8) * sizeof (TCHAR));
|
|
pThisSymbol->SymbolName = MemoryAllocate (DISP_BUFF_SIZE * sizeof (TCHAR));
|
|
|
|
if (!pThisSymbol->SymbolName) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
// all the memory is allocated so load the fields
|
|
|
|
pThisSymbol->pNext = NULL;
|
|
|
|
iNumArgs = sscanf (lpLineBuffer, "#define %s %d",
|
|
lpAnsiSymbol, &pThisSymbol->Value);
|
|
|
|
if (iNumArgs != 2) {
|
|
*(pThisSymbol->SymbolName) = 0;
|
|
pThisSymbol->Value = (DWORD)-1L;
|
|
bReUse = TRUE;
|
|
} else {
|
|
// OemToChar (lpAnsiSymbol, pThisSymbol->SymbolName);
|
|
mbstowcs (pThisSymbol->SymbolName,
|
|
lpAnsiSymbol, lstrlenA(lpAnsiSymbol)+1);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADINCLUDEFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIncludeFileName),
|
|
TRACE_WSTR(pThisSymbol->SymbolName),
|
|
TRACE_DWORD(pThisSymbol->Value),
|
|
NULL));
|
|
bReUse = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
if (! bReturn) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADINCLUDEFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
GetLastError(),
|
|
TRACE_WSTR(lpIniFile),
|
|
NULL));
|
|
}
|
|
if (lpIncludeFileName) MemoryFree(lpIncludeFileName);
|
|
if (lpIncludeFile) MemoryFree(lpIncludeFile);
|
|
if (lpLineBuffer) MemoryFree(lpLineBuffer);
|
|
if (lpIniPath) MemoryFree(lpIniPath);
|
|
if (fIncludeFile != NULL) fclose(fIncludeFile);
|
|
|
|
return bReturn;
|
|
|
|
}
|
|
|
|
BOOL
|
|
ParseTextId (
|
|
IN LPTSTR lpTextId,
|
|
IN PSYMBOL_TABLE_ENTRY pFirstSymbol,
|
|
OUT PDWORD pdwOffset,
|
|
OUT LPTSTR *lpLangId,
|
|
OUT PDWORD pdwType
|
|
)
|
|
/*++
|
|
|
|
ParseTextId
|
|
|
|
decodes Text Id key from .INI file
|
|
|
|
syntax for this process is:
|
|
|
|
{<DecimalNumber>} {"NAME"}
|
|
{<SymbolInTable>}_<LangIdString>_{"HELP"}
|
|
|
|
e.g. 0_009_NAME
|
|
OBJECT_1_009_HELP
|
|
|
|
Arguments
|
|
|
|
lpTextId
|
|
|
|
string to decode
|
|
|
|
pFirstSymbol
|
|
|
|
pointer to first entry in symbol table (NULL if no table)
|
|
|
|
pdwOffset
|
|
|
|
address of DWORD to recive offest value
|
|
|
|
lpLangId
|
|
|
|
address of pointer to Language Id string
|
|
(NOTE: this will point into the string lpTextID which will be
|
|
modified by this routine)
|
|
|
|
pdwType
|
|
|
|
pointer to dword that will recieve the type of string i.e.
|
|
HELP or NAME
|
|
|
|
Return Value
|
|
|
|
TRUE text Id decoded successfully
|
|
FALSE unable to decode string
|
|
|
|
NOTE: the string in lpTextID will be modified by this procedure
|
|
|
|
--*/
|
|
{
|
|
LPTSTR lpThisChar;
|
|
PSYMBOL_TABLE_ENTRY pThisSymbol;
|
|
|
|
// check for valid return arguments
|
|
|
|
if (!(pdwOffset) || !(lpLangId) || !(pdwType)) {
|
|
SetLastError (ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
// search string from right to left in order to identify the
|
|
// components of the string.
|
|
|
|
lpThisChar = lpTextId + lstrlen(lpTextId); // point to end of string
|
|
|
|
while (*lpThisChar != cUnderscore) {
|
|
lpThisChar--;
|
|
if (lpThisChar <= lpTextId) {
|
|
// underscore not found in string
|
|
SetLastError (ERROR_INVALID_DATA);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// first underscore found
|
|
|
|
if ((lstrcmpi(lpThisChar, szName)) == 0) {
|
|
// name found, so set type
|
|
*pdwType = TYPE_NAME;
|
|
} else if ((lstrcmpi(lpThisChar, szHelp)) == 0) {
|
|
// help text found, so set type
|
|
*pdwType = TYPE_HELP;
|
|
} else {
|
|
// bad format
|
|
SetLastError (ERROR_INVALID_DATA);
|
|
return FALSE;
|
|
}
|
|
|
|
// set the current underscore to \0 and look for language ID
|
|
|
|
*lpThisChar-- = 0;
|
|
|
|
while (*lpThisChar != cUnderscore) {
|
|
lpThisChar--;
|
|
if (lpThisChar <= lpTextId) {
|
|
// underscore not found in string
|
|
SetLastError (ERROR_INVALID_DATA);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// set lang ID string pointer to current char ('_') + 1
|
|
|
|
*lpLangId = lpThisChar + 1;
|
|
|
|
// set this underscore to a NULL and try to decode the remaining text
|
|
|
|
*lpThisChar = 0;
|
|
|
|
// see if the first part of the string is a decimal digit
|
|
|
|
if ((_stscanf (lpTextId, sz_DFormat, pdwOffset)) != 1) {
|
|
// it's not a digit, so try to decode it as a symbol in the
|
|
// loaded symbol table
|
|
|
|
for (pThisSymbol=pFirstSymbol;
|
|
pThisSymbol && *(pThisSymbol->SymbolName);
|
|
pThisSymbol = pThisSymbol->pNext) {
|
|
|
|
if ((lstrcmpi(lpTextId, pThisSymbol->SymbolName)) == 0) {
|
|
// a matching symbol was found, so insert it's value
|
|
// and return (that's all that needs to be done
|
|
*pdwOffset = pThisSymbol->Value;
|
|
return TRUE;
|
|
}
|
|
}
|
|
// if here, then no matching symbol was found, and it's not
|
|
// a number, so return an error
|
|
|
|
SetLastError (ERROR_BAD_TOKEN_TYPE);
|
|
return FALSE;
|
|
} else {
|
|
// symbol was prefixed with a decimal number
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
PLANGUAGE_LIST_ELEMENT
|
|
FindLanguage (
|
|
IN PLANGUAGE_LIST_ELEMENT pFirstLang,
|
|
IN LPCTSTR pLangId
|
|
)
|
|
/*++
|
|
|
|
FindLanguage
|
|
|
|
searchs the list of languages and returns a pointer to the language
|
|
list entry that matches the pLangId string argument
|
|
|
|
Arguments
|
|
|
|
pFirstLang
|
|
|
|
pointer to first language list element
|
|
|
|
pLangId
|
|
|
|
pointer to text string with language ID to look up
|
|
|
|
Return Value
|
|
|
|
Pointer to matching language list entry
|
|
or NULL if no match
|
|
|
|
--*/
|
|
{
|
|
PLANGUAGE_LIST_ELEMENT pThisLang;
|
|
|
|
for (pThisLang = pFirstLang;
|
|
pThisLang;
|
|
pThisLang = pThisLang->pNextLang) {
|
|
if ((lstrcmpi(pLangId, pThisLang->LangId)) == 0) {
|
|
// match found so return pointer
|
|
return pThisLang;
|
|
}
|
|
}
|
|
return NULL; // no match found
|
|
}
|
|
|
|
BOOL
|
|
GetValue(
|
|
LPTSTR lpLocalSectionBuff,
|
|
LPTSTR lpLocalStringBuff
|
|
)
|
|
{
|
|
|
|
LPTSTR lpPosition;
|
|
|
|
BOOL bReturn = FALSE;
|
|
|
|
lpPosition = _tcschr(lpLocalSectionBuff,cEquals);
|
|
if (lpPosition) {
|
|
lpPosition++;
|
|
// make sure the "=" isn't the last char
|
|
if (*lpPosition != 0) {
|
|
//Found the "equals" sign
|
|
lstrcpy (lpLocalStringBuff,lpPosition);
|
|
} else {
|
|
// empty string, return a pseudo blank string
|
|
lstrcpy(lpLocalStringBuff, L" ");
|
|
}
|
|
bReturn = TRUE;
|
|
} else {
|
|
//ErrorFinfing the "="
|
|
// bad format
|
|
SetLastError (ERROR_INVALID_DATA);
|
|
}
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
GetValueFromIniKey (LPTSTR lpValueKey,
|
|
LPTSTR lpTextSection,
|
|
DWORD* pdwLastReadOffset,
|
|
DWORD dwTryCount,
|
|
LPTSTR lpLocalStringBuff
|
|
)
|
|
{
|
|
LPTSTR lpLocalSectionBuff;
|
|
DWORD dwIndex;
|
|
DWORD dwLastReadOffset;
|
|
BOOL bRetVal = FALSE;
|
|
|
|
if ((lpTextSection) && (lpValueKey)) {
|
|
dwLastReadOffset = *pdwLastReadOffset;
|
|
lpLocalSectionBuff = lpTextSection ;
|
|
lpLocalSectionBuff += dwLastReadOffset;
|
|
|
|
while(!(*lpLocalSectionBuff)){
|
|
|
|
dwLastReadOffset += (lstrlen(lpTextSection + dwLastReadOffset) + 1);
|
|
lpLocalSectionBuff = lpTextSection + dwLastReadOffset;
|
|
*pdwLastReadOffset = dwLastReadOffset;
|
|
|
|
}
|
|
|
|
// search next N entries in buffer for entry
|
|
// this should usually work since the file
|
|
// is scanned sequentially so it's tried first
|
|
for (dwIndex = 0;
|
|
dwIndex < dwTryCount ;
|
|
dwIndex++) {
|
|
// see if this is the correct entry
|
|
// and return it if it is
|
|
if (_tcsstr(lpLocalSectionBuff,lpValueKey)) {
|
|
bRetVal = GetValue(lpLocalSectionBuff,
|
|
lpLocalStringBuff);
|
|
//Set the lastReadOffset First
|
|
dwLastReadOffset += (lstrlen(lpTextSection + dwLastReadOffset) + 1);
|
|
*pdwLastReadOffset = dwLastReadOffset;
|
|
break; // out of the for loop
|
|
} else {
|
|
// this isn't the correct one so go to the next
|
|
// entry in the file
|
|
dwLastReadOffset += (lstrlen(lpTextSection + dwLastReadOffset) + 1);
|
|
lpLocalSectionBuff = lpTextSection + dwLastReadOffset;
|
|
*pdwLastReadOffset = dwLastReadOffset;
|
|
}
|
|
}
|
|
|
|
if (!bRetVal) {
|
|
//Cannont Find the key using lastReadOffset
|
|
//try again from the beggining of the Array
|
|
dwLastReadOffset = 0;
|
|
lpLocalSectionBuff = lpTextSection;
|
|
*pdwLastReadOffset = dwLastReadOffset;
|
|
|
|
while (*lpLocalSectionBuff != 0) {
|
|
if (_tcsstr(lpLocalSectionBuff,lpValueKey)) {
|
|
bRetVal = GetValue(lpLocalSectionBuff,
|
|
lpLocalStringBuff);
|
|
break;
|
|
} else {
|
|
// go to the next entry
|
|
dwLastReadOffset += (lstrlen(lpTextSection + dwLastReadOffset) + 1);
|
|
lpLocalSectionBuff = lpTextSection + dwLastReadOffset;
|
|
*pdwLastReadOffset = dwLastReadOffset;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// one or two null pointers so give up now
|
|
}
|
|
return bRetVal;
|
|
}
|
|
|
|
BOOL
|
|
AddEntryToLanguage (
|
|
PLANGUAGE_LIST_ELEMENT pLang,
|
|
LPTSTR lpValueKey,
|
|
LPTSTR lpTextSection,
|
|
DWORD *pdwLastReadOffset,
|
|
DWORD dwTryCount,
|
|
DWORD dwType,
|
|
DWORD dwOffset,
|
|
LPTSTR lpIniFile
|
|
)
|
|
/*++
|
|
|
|
AddEntryToLanguage
|
|
|
|
Add a text entry to the list of text entries for the specified language
|
|
|
|
Arguments
|
|
|
|
pLang
|
|
|
|
pointer to language structure to update
|
|
|
|
lpValueKey
|
|
|
|
value key to look up in .ini file
|
|
|
|
dwOffset
|
|
|
|
numeric offset of name in registry
|
|
|
|
lpIniFile
|
|
|
|
ini file
|
|
|
|
Return Value
|
|
|
|
TRUE if added successfully
|
|
FALSE if error
|
|
(see GetLastError for status)
|
|
|
|
--*/
|
|
{
|
|
LPTSTR lpLocalStringBuff = NULL;
|
|
DWORD dwBufferSize;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
BOOL bRetVal;
|
|
BOOL bReturn = FALSE;
|
|
|
|
UNREFERENCED_PARAMETER (lpIniFile);
|
|
|
|
if ( (dwType == TYPE_NAME && dwOffset < FIRST_EXT_COUNTER_INDEX)
|
|
|| (dwType == TYPE_HELP && dwOffset < FIRST_EXT_HELP_INDEX)) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE,
|
|
(DWORD) LDPRFMSG_CORRUPT_INDEX,
|
|
3, dwOffset, dwType, __LINE__, 0,
|
|
1, lpValueKey, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_ADDENTRYTOLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpTextSection),
|
|
TRACE_WSTR(lpValueKey),
|
|
TRACE_DWORD(dwType),
|
|
TRACE_DWORD(dwOffset),
|
|
NULL));
|
|
dwStatus = ERROR_BADKEY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwBufferSize = SMALL_BUFFER_SIZE * 4 * sizeof(TCHAR);
|
|
if (dwBufferSize < dwFileSize) {
|
|
dwBufferSize = dwFileSize;
|
|
}
|
|
|
|
lpLocalStringBuff = MemoryAllocate (dwBufferSize);
|
|
|
|
if (!lpLocalStringBuff) {
|
|
dwStatus = ERROR_OUTOFMEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
bRetVal = GetValueFromIniKey(lpValueKey,
|
|
lpTextSection,
|
|
pdwLastReadOffset,
|
|
dwTryCount,
|
|
lpLocalStringBuff);
|
|
|
|
if (!bRetVal) {
|
|
DWORD dwLastReadOffset = * pdwLastReadOffset;
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_ADDENTRYTOLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpTextSection),
|
|
TRACE_WSTR(lpValueKey),
|
|
TRACE_DWORD(dwLastReadOffset),
|
|
NULL));
|
|
dwStatus = ERROR_BADKEY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if ((lstrcmpi(lpLocalStringBuff, szNotFound))== 0) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_ADDENTRYTOLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpTextSection),
|
|
TRACE_WSTR(lpValueKey),
|
|
NULL));
|
|
dwStatus = ERROR_BADKEY;
|
|
goto Cleanup;
|
|
}
|
|
// key found, so load structure
|
|
|
|
if (!pLang->pThisName) {
|
|
// this is the first
|
|
pLang->pThisName =
|
|
MemoryAllocate (sizeof (NAME_ENTRY) +
|
|
(lstrlen(lpLocalStringBuff) + 1) * sizeof (TCHAR));
|
|
if (!pLang->pThisName) {
|
|
dwStatus = ERROR_OUTOFMEMORY;
|
|
goto Cleanup;
|
|
} else {
|
|
pLang->pFirstName = pLang->pThisName;
|
|
}
|
|
} else {
|
|
pLang->pThisName->pNext =
|
|
MemoryAllocate (sizeof (NAME_ENTRY) +
|
|
(lstrlen(lpLocalStringBuff) + 1) * sizeof (TCHAR));
|
|
if (!pLang->pThisName->pNext) {
|
|
dwStatus = ERROR_OUTOFMEMORY;
|
|
goto Cleanup;
|
|
} else {
|
|
pLang->pThisName = pLang->pThisName->pNext;
|
|
}
|
|
}
|
|
|
|
// pLang->pThisName now points to an uninitialized structre
|
|
|
|
pLang->pThisName->pNext = NULL;
|
|
pLang->pThisName->dwOffset = dwOffset;
|
|
pLang->pThisName->dwType = dwType;
|
|
pLang->pThisName->lpText = (LPTSTR) & (pLang->pThisName[1]);
|
|
lstrcpy (pLang->pThisName->lpText, lpLocalStringBuff);
|
|
bReturn = TRUE;
|
|
|
|
Cleanup:
|
|
if (lpLocalStringBuff != NULL) MemoryFree (lpLocalStringBuff);
|
|
SetLastError(dwStatus);
|
|
return (bReturn);
|
|
}
|
|
|
|
BOOL
|
|
CreateObjectList (
|
|
IN LPTSTR lpIniFile,
|
|
IN DWORD dwFirstDriverCounter,
|
|
IN PSYMBOL_TABLE_ENTRY pFirstSymbol,
|
|
IN LPTSTR lpszObjectList,
|
|
IN PPERFOBJECT_LOOKUP pObjectGuidTable,
|
|
IN LPDWORD pdwObjectGuidTableEntries
|
|
)
|
|
{
|
|
TCHAR szDigits[32];
|
|
LPTSTR szLangId;
|
|
TCHAR szTempString[256];
|
|
LPWSTR szGuidStringBuffer;
|
|
LPTSTR szThisKey;
|
|
DWORD dwSize;
|
|
DWORD dwObjectCount = 0;
|
|
DWORD dwId;
|
|
DWORD dwType;
|
|
DWORD dwObjectGuidIndex = 0;
|
|
|
|
DWORD dwBufferSize = dwFileSize;
|
|
LPTSTR szObjectSectionEntries = NULL;
|
|
BOOL bResult = TRUE;
|
|
|
|
if (dwBufferSize < MAX_PROFILE_BUFFER * sizeof(TCHAR)) {
|
|
dwBufferSize = MAX_PROFILE_BUFFER * sizeof(TCHAR);
|
|
}
|
|
szObjectSectionEntries = MemoryAllocate(dwBufferSize);
|
|
if (szObjectSectionEntries == NULL) {
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ZeroMemory(szObjectSectionEntries, dwBufferSize);
|
|
szThisKey = & szObjectSectionEntries[0];
|
|
|
|
dwSize = GetPrivateProfileString (
|
|
szObjects,
|
|
NULL,
|
|
szNotFound,
|
|
szObjectSectionEntries,
|
|
dwBufferSize / sizeof(TCHAR),
|
|
lpIniFile);
|
|
|
|
* lpszObjectList = 0;
|
|
if (lstrcmp(szObjectSectionEntries, szNotFound) != 0) {
|
|
// then some entries were found so read each one, compute the
|
|
// index value and save in the string buffer passed by the caller
|
|
for (szThisKey = szObjectSectionEntries;
|
|
*szThisKey != 0;
|
|
szThisKey += lstrlen(szThisKey) + 1) {
|
|
// ParstTextId modifies the string so we need to make a work copy
|
|
lstrcpy (szTempString, szThisKey);
|
|
if (ParseTextId(szTempString, pFirstSymbol, &dwId, &szLangId, &dwType)) {
|
|
// then dwID is the id of an object supported by this DLL
|
|
if (dwObjectCount != 0) {
|
|
lstrcat (lpszObjectList, szSpace);
|
|
}
|
|
_ultot ((dwId + dwFirstDriverCounter), szDigits, 10);
|
|
lstrcat (lpszObjectList, szDigits);
|
|
//
|
|
// now see if this object has a GUID string
|
|
//
|
|
szGuidStringBuffer = MemoryAllocate(1024);
|
|
if (szGuidStringBuffer == NULL) {
|
|
// cannot allocate memory for szGuidStringBuffer, ignore
|
|
// and continue the next one.
|
|
//
|
|
dwObjectCount ++;
|
|
continue;
|
|
}
|
|
dwSize = GetPrivateProfileStringW (
|
|
szObjects,
|
|
szThisKey,
|
|
szNotFound,
|
|
szGuidStringBuffer,
|
|
1024,
|
|
lpIniFile);
|
|
if (dwSize > 0) {
|
|
if (lstrcmpW (szGuidStringBuffer, szNotFound) != 0) {
|
|
// then some string is present, so see if
|
|
// it looks like a GUID
|
|
if ((szGuidStringBuffer[0] == L'{') &&
|
|
(szGuidStringBuffer[9] == L'-') &&
|
|
(szGuidStringBuffer[14] == L'-') &&
|
|
(szGuidStringBuffer[19] == L'-') &&
|
|
(szGuidStringBuffer[24] == L'-') &&
|
|
(szGuidStringBuffer[37] == L'}')) {
|
|
// then it's probably a GUID so store it
|
|
szGuidStringBuffer = MemoryResize (szGuidStringBuffer,
|
|
(dwSize + 1) * sizeof(WCHAR));
|
|
if (szGuidStringBuffer == NULL) {
|
|
// cannot reallocate memory for
|
|
// szGuidStringBuffer, ignore and continue
|
|
// the next one.
|
|
//
|
|
continue;
|
|
}
|
|
if (dwObjectGuidIndex < *pdwObjectGuidTableEntries) {
|
|
pObjectGuidTable[dwObjectGuidIndex].PerfObjectId =
|
|
dwId + dwFirstDriverCounter;
|
|
pObjectGuidTable[dwObjectGuidIndex].GuidString =
|
|
szGuidStringBuffer;
|
|
dwObjectGuidIndex++;
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CREATEOBJECTLIST,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(szGuidStringBuffer),
|
|
TRACE_DWORD(dwObjectGuidIndex),
|
|
NULL));
|
|
} else {
|
|
// table is full
|
|
}
|
|
} else {
|
|
// not a GUID so ignore
|
|
}
|
|
} else {
|
|
// no string after object reference
|
|
}
|
|
}
|
|
dwObjectCount++;
|
|
} else {
|
|
// invalid key format
|
|
}
|
|
}
|
|
// save size of Guid Table
|
|
*pdwObjectGuidTableEntries = dwObjectGuidIndex;
|
|
} else {
|
|
// log message that object list is not used
|
|
TRACE((WINPERF_DBG_TRACE_WARNING),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CREATEOBJECTLIST,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstDriverCounter),
|
|
NULL));
|
|
}
|
|
|
|
Cleanup:
|
|
if (szObjectSectionEntries != NULL) {
|
|
MemoryFree(szObjectSectionEntries);
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
LoadLanguageLists (
|
|
IN LPTSTR lpIniFile,
|
|
IN DWORD dwFirstCounter,
|
|
IN DWORD dwFirstHelp,
|
|
IN PSYMBOL_TABLE_ENTRY pFirstSymbol,
|
|
IN PLANGUAGE_LIST_ELEMENT pFirstLang
|
|
)
|
|
/*++
|
|
|
|
LoadLanguageLists
|
|
|
|
Reads in the name and explain text definitions from the ini file and
|
|
builds a list of these items for each of the supported languages and
|
|
then combines all the entries into a sorted MULTI_SZ string buffer.
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
|
|
file containing the definitions to add to the registry
|
|
|
|
dwFirstCounter
|
|
|
|
starting counter name index number
|
|
|
|
dwFirstHelp
|
|
|
|
starting help text index number
|
|
|
|
pFirstLang
|
|
|
|
pointer to first element in list of language elements
|
|
|
|
Return Value
|
|
|
|
TRUE if all is well
|
|
FALSE if not
|
|
error is returned in GetLastError
|
|
|
|
--*/
|
|
{
|
|
LPTSTR lpTextIdArray;
|
|
LPTSTR lpLocalKey;
|
|
LPTSTR lpThisKey;
|
|
LPTSTR lpTextSectionArray;
|
|
DWORD dwSize;
|
|
LPTSTR lpLang;
|
|
DWORD dwOffset;
|
|
DWORD dwType;
|
|
PLANGUAGE_LIST_ELEMENT pThisLang, pLangPointer=NULL;
|
|
DWORD dwBufferSize;
|
|
DWORD dwSuccessCount = 0;
|
|
DWORD dwErrorCount = 0;
|
|
DWORD dwLastReadOffset = 0;
|
|
DWORD dwTryCount = 4; //Init this value with 4 (at least 4 times to try maching Key and Value)
|
|
|
|
pLangPointer = pFirstLang;
|
|
|
|
while (pFirstLang) {
|
|
pFirstLang = pFirstLang->pNextLang;
|
|
//if you have more languages then increase this try limit to 4 + No. of langs
|
|
dwTryCount++;
|
|
}
|
|
pFirstLang = pLangPointer;
|
|
|
|
dwBufferSize = SMALL_BUFFER_SIZE * 4 * sizeof(TCHAR);
|
|
if (dwBufferSize < dwFileSize) {
|
|
dwBufferSize = dwFileSize;
|
|
}
|
|
|
|
lpTextIdArray = MemoryAllocate (dwBufferSize);
|
|
if (lpTextIdArray == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_OUTOFMEMORY,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstCounter),
|
|
TRACE_DWORD(dwFirstHelp),
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
lpLocalKey = MemoryAllocate (MAX_PATH * sizeof(TCHAR));
|
|
if (lpLocalKey == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
if (lpTextIdArray) MemoryFree (lpTextIdArray);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_OUTOFMEMORY,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstCounter),
|
|
TRACE_DWORD(dwFirstHelp),
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
lpTextSectionArray = MemoryAllocate (dwBufferSize);
|
|
if (lpTextSectionArray == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
if (lpTextIdArray) MemoryFree(lpTextIdArray);
|
|
if (lpLocalKey) MemoryFree(lpLocalKey);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_OUTOFMEMORY,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstCounter),
|
|
TRACE_DWORD(dwFirstHelp),
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstCounter),
|
|
TRACE_DWORD(dwFirstHelp),
|
|
NULL));
|
|
|
|
// get list of text keys to look up
|
|
|
|
dwSize = GetPrivateProfileString (
|
|
szText, // [text] section of .INI file
|
|
NULL, // return all keys
|
|
szNotFound,
|
|
lpTextIdArray, // return buffer
|
|
dwBufferSize / sizeof(TCHAR),
|
|
lpIniFile); // .INI file name
|
|
|
|
if ((lstrcmpi(lpTextIdArray, szNotFound)) == 0) {
|
|
// key not found, default returned
|
|
SetLastError (ERROR_NO_SUCH_GROUP);
|
|
if (lpTextIdArray) MemoryFree(lpTextIdArray);
|
|
if (lpLocalKey) MemoryFree(lpLocalKey);
|
|
if (lpTextSectionArray) MemoryFree(lpTextSectionArray);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_NO_SUCH_GROUP,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_DWORD(dwFirstCounter),
|
|
TRACE_DWORD(dwFirstHelp),
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
// get the the [text] section from the ini file
|
|
|
|
dwSize = GetPrivateProfileSection (
|
|
szText, // [text] section of .INI file
|
|
lpTextSectionArray, // return buffer
|
|
dwBufferSize / sizeof(TCHAR),
|
|
lpIniFile); // .INI file name
|
|
|
|
// do each key returned
|
|
|
|
for (lpThisKey=lpTextIdArray;
|
|
* lpThisKey;
|
|
lpThisKey += (lstrlen(lpThisKey) + 1)) {
|
|
|
|
lstrcpy (lpLocalKey, lpThisKey); // make a copy of the key
|
|
|
|
// parse key to see if it's in the correct format
|
|
|
|
if (ParseTextId(lpLocalKey, pFirstSymbol, &dwOffset, &lpLang, &dwType)) {
|
|
// so get pointer to language entry structure
|
|
pThisLang = FindLanguage (pFirstLang, lpLang);
|
|
if (pThisLang) {
|
|
if (!AddEntryToLanguage(pThisLang,
|
|
lpThisKey,
|
|
lpTextSectionArray,
|
|
& dwLastReadOffset,
|
|
dwTryCount,
|
|
dwType,
|
|
(dwOffset + ( (dwType == TYPE_NAME)
|
|
? dwFirstCounter
|
|
: dwFirstHelp)),
|
|
lpIniFile)) {
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_ERRADDTOLANG),
|
|
lpThisKey,
|
|
lpLang,
|
|
GetLastError());
|
|
dwErrorCount ++;
|
|
} else {
|
|
dwSuccessCount ++;
|
|
}
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpThisKey),
|
|
TRACE_WSTR(lpLang),
|
|
TRACE_DWORD(dwOffset),
|
|
TRACE_DWORD(dwType),
|
|
NULL));
|
|
} else { // language not in list
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_LANGNOTFOUND), lpLang, lpThisKey);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(lpThisKey),
|
|
TRACE_WSTR(lpLang),
|
|
NULL));
|
|
}
|
|
} else { // unable to parse ID string
|
|
OUTPUT_MESSAGE(GetFormatResource(LC_BAD_KEY), lpThisKey);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADLANGUAGELISTS,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpThisKey),
|
|
TRACE_WSTR(lpLang),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
if (lpTextIdArray) MemoryFree(lpTextIdArray);
|
|
if (lpLocalKey) MemoryFree(lpLocalKey);
|
|
if (lpTextSectionArray) MemoryFree(lpTextSectionArray);
|
|
|
|
return (BOOL) (dwErrorCount == 0);
|
|
}
|
|
|
|
BOOL
|
|
SortLanguageTables (
|
|
PLANGUAGE_LIST_ELEMENT pFirstLang,
|
|
PDWORD pdwLastName,
|
|
PDWORD pdwLastHelp
|
|
)
|
|
/*++
|
|
|
|
SortLangageTables
|
|
|
|
walks list of languages loaded, allocates and loads a sorted multi_SZ
|
|
buffer containing new entries to be added to current names/help text
|
|
|
|
Arguments
|
|
|
|
pFirstLang
|
|
|
|
pointer to first element in list of languages
|
|
|
|
ReturnValue
|
|
|
|
TRUE everything done as expected
|
|
FALSE error occurred, status in GetLastError
|
|
|
|
--*/
|
|
{
|
|
PLANGUAGE_LIST_ELEMENT pThisLang;
|
|
|
|
BOOL bSorted;
|
|
|
|
LPTSTR pNameBufPos, pHelpBufPos;
|
|
|
|
PNAME_ENTRY pThisName, pPrevName;
|
|
|
|
DWORD dwHelpSize, dwNameSize, dwSize;
|
|
DWORD dwCurrentLastName;
|
|
DWORD dwCurrentLastHelp;
|
|
|
|
if (!pdwLastName || !pdwLastHelp) {
|
|
SetLastError (ERROR_BAD_ARGUMENTS);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SORTLANGUAGETABLES,
|
|
0,
|
|
ERROR_BAD_ARGUMENTS,
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
for (pThisLang = pFirstLang;
|
|
pThisLang;
|
|
pThisLang = pThisLang->pNextLang) {
|
|
// do each language in list
|
|
// sort elements in list by value (offset) so that lowest is first
|
|
|
|
if (pThisLang->pFirstName == NULL) {
|
|
// no elements in this list, continue the next one
|
|
continue;
|
|
}
|
|
|
|
bSorted = FALSE;
|
|
while (!bSorted ) {
|
|
// point to start of list
|
|
|
|
pPrevName = pThisLang->pFirstName;
|
|
if (pPrevName) {
|
|
pThisName = pPrevName->pNext;
|
|
} else {
|
|
break; // no elements in this list
|
|
}
|
|
|
|
if (!pThisName) {
|
|
break; // only one element in the list
|
|
}
|
|
bSorted = TRUE; // assume that it's sorted
|
|
|
|
// go until end of list
|
|
|
|
while (pThisName->pNext) {
|
|
if (pThisName->dwOffset > pThisName->pNext->dwOffset) {
|
|
// switch 'em
|
|
PNAME_ENTRY pA, pB;
|
|
pPrevName->pNext = pThisName->pNext;
|
|
pA = pThisName->pNext;
|
|
pB = pThisName->pNext->pNext;
|
|
pThisName->pNext = pB;
|
|
pA->pNext = pThisName;
|
|
pThisName = pA;
|
|
bSorted = FALSE;
|
|
}
|
|
//move to next entry
|
|
pPrevName = pThisName;
|
|
pThisName = pThisName->pNext;
|
|
}
|
|
// if bSorted = TRUE , then we walked all the way down
|
|
// the list without changing anything so that's the end.
|
|
}
|
|
|
|
// with the list sorted, build the MULTI_SZ strings for the
|
|
// help and name text strings
|
|
|
|
// compute buffer size
|
|
|
|
dwNameSize = dwHelpSize = 0;
|
|
dwCurrentLastName = 0;
|
|
dwCurrentLastHelp = 0;
|
|
|
|
for (pThisName = pThisLang->pFirstName;
|
|
pThisName;
|
|
pThisName = pThisName->pNext) {
|
|
// compute buffer requirements for this entry
|
|
dwSize = SIZE_OF_OFFSET_STRING;
|
|
dwSize += lstrlen (pThisName->lpText);
|
|
dwSize += 1; // null
|
|
dwSize *= sizeof (TCHAR); // adjust for character size
|
|
// add to appropriate size register
|
|
if (pThisName->dwType == TYPE_NAME) {
|
|
dwNameSize += dwSize;
|
|
if (pThisName->dwOffset > dwCurrentLastName) {
|
|
dwCurrentLastName = pThisName->dwOffset;
|
|
}
|
|
} else if (pThisName->dwType == TYPE_HELP) {
|
|
dwHelpSize += dwSize;
|
|
if (pThisName->dwOffset > dwCurrentLastHelp) {
|
|
dwCurrentLastHelp = pThisName->dwOffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
// allocate buffers for the Multi_SZ strings
|
|
|
|
pThisLang->NameBuffer = MemoryAllocate (dwNameSize);
|
|
pThisLang->HelpBuffer = MemoryAllocate (dwHelpSize);
|
|
|
|
if (!pThisLang->NameBuffer || !pThisLang->HelpBuffer) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SORTLANGUAGETABLES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_OUTOFMEMORY,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_DWORD(pThisLang->dwNumElements),
|
|
TRACE_DWORD(dwCurrentLastName),
|
|
TRACE_DWORD(dwCurrentLastHelp),
|
|
NULL));
|
|
return FALSE;
|
|
}
|
|
|
|
// fill in buffers with sorted strings
|
|
|
|
pNameBufPos = (LPTSTR)pThisLang->NameBuffer;
|
|
pHelpBufPos = (LPTSTR)pThisLang->HelpBuffer;
|
|
|
|
for (pThisName = pThisLang->pFirstName;
|
|
pThisName;
|
|
pThisName = pThisName->pNext) {
|
|
if (pThisName->dwType == TYPE_NAME) {
|
|
// load number as first 0-term. string
|
|
dwSize = _stprintf (pNameBufPos, szDFormat, pThisName->dwOffset);
|
|
pNameBufPos += dwSize + 1; // save NULL term.
|
|
// load the text to match
|
|
lstrcpy (pNameBufPos, pThisName->lpText);
|
|
pNameBufPos += lstrlen(pNameBufPos) + 1;
|
|
} else if (pThisName->dwType == TYPE_HELP) {
|
|
// load number as first 0-term. string
|
|
dwSize = _stprintf (pHelpBufPos, szDFormat, pThisName->dwOffset);
|
|
pHelpBufPos += dwSize + 1; // save NULL term.
|
|
// load the text to match
|
|
lstrcpy (pHelpBufPos, pThisName->lpText);
|
|
pHelpBufPos += lstrlen(pHelpBufPos) + 1;
|
|
}
|
|
}
|
|
|
|
// add additional NULL at end of string to terminate MULTI_SZ
|
|
|
|
* pHelpBufPos = 0;
|
|
* pNameBufPos = 0;
|
|
|
|
// compute size of MULTI_SZ strings
|
|
|
|
pThisLang->dwNameBuffSize = (DWORD)((PBYTE)pNameBufPos -
|
|
(PBYTE)pThisLang->NameBuffer) +
|
|
sizeof(TCHAR);
|
|
pThisLang->dwHelpBuffSize = (DWORD)((PBYTE)pHelpBufPos -
|
|
(PBYTE)pThisLang->HelpBuffer) +
|
|
sizeof(TCHAR);
|
|
|
|
if (* pdwLastName < dwCurrentLastName) {
|
|
* pdwLastName = dwCurrentLastName;
|
|
}
|
|
if (* pdwLastHelp < dwCurrentLastHelp) {
|
|
* pdwLastHelp = dwCurrentLastHelp;
|
|
}
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SORTLANGUAGETABLES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_DWORD(pThisLang->dwNumElements),
|
|
TRACE_DWORD(dwCurrentLastName),
|
|
TRACE_DWORD(dwCurrentLastHelp),
|
|
NULL));
|
|
}
|
|
|
|
dwCurrentLastName = * pdwLastName;
|
|
dwCurrentLastHelp = * pdwLastHelp;
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SORTLANGUAGETABLES,
|
|
0,
|
|
ERROR_SUCCESS,
|
|
TRACE_DWORD(dwCurrentLastName),
|
|
TRACE_DWORD(dwCurrentLastHelp),
|
|
NULL));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
GetInstalledLanguageList (
|
|
HKEY hPerflibRoot,
|
|
LPTSTR *mszLangList
|
|
)
|
|
/*++
|
|
returns a list of language sub keys found under the perflib key
|
|
|
|
--*/
|
|
{
|
|
BOOL bReturn = TRUE;
|
|
LONG lStatus;
|
|
DWORD dwIndex = 0;
|
|
LPTSTR szBuffer;
|
|
DWORD dwBufSize;
|
|
LPTSTR szRetBuffer = NULL;
|
|
DWORD dwRetBufSize = 0;
|
|
DWORD dwLastBufSize = 0;
|
|
LPTSTR szNextString;
|
|
|
|
dwBufSize = MAX_PATH;
|
|
szBuffer = MemoryAllocate(MAX_PATH * sizeof(TCHAR));
|
|
|
|
if (szBuffer == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
}
|
|
|
|
if (bReturn) {
|
|
while ((lStatus = RegEnumKeyEx (hPerflibRoot,
|
|
dwIndex, szBuffer, &dwBufSize,
|
|
NULL, NULL, NULL, NULL)) == ERROR_SUCCESS) {
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_GETINSTALLEDLANGUAGELIST,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(szBuffer),
|
|
TRACE_DWORD(dwIndex),
|
|
NULL));
|
|
|
|
dwRetBufSize += (lstrlen(szBuffer) + 1) * sizeof(TCHAR);
|
|
if (szRetBuffer != NULL) {
|
|
LPTSTR szTmpBuffer = szRetBuffer;
|
|
szRetBuffer = MemoryResize(szRetBuffer, dwRetBufSize);
|
|
if (szRetBuffer == NULL) {
|
|
MemoryFree(szTmpBuffer);
|
|
}
|
|
} else {
|
|
szRetBuffer = MemoryAllocate(dwRetBufSize);
|
|
}
|
|
|
|
if (szRetBuffer == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_GETINSTALLEDLANGUAGELIST,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_OUTOFMEMORY,
|
|
TRACE_WSTR(szBuffer),
|
|
TRACE_DWORD(dwIndex),
|
|
NULL));
|
|
break;
|
|
}
|
|
|
|
szNextString = (LPTSTR) ((LPBYTE) szRetBuffer + dwLastBufSize);
|
|
lstrcpy(szNextString, szBuffer);
|
|
dwLastBufSize = dwRetBufSize;
|
|
dwIndex ++;
|
|
dwBufSize = MAX_PATH;
|
|
RtlZeroMemory(szBuffer, MAX_PATH * sizeof(TCHAR));
|
|
}
|
|
}
|
|
|
|
if (bReturn) {
|
|
LPTSTR szTmpBuffer = szRetBuffer;
|
|
// add terminating null char
|
|
dwRetBufSize += sizeof (TCHAR);
|
|
if (szRetBuffer != NULL) {
|
|
szRetBuffer = MemoryResize(szRetBuffer, dwRetBufSize);
|
|
} else {
|
|
szRetBuffer = MemoryAllocate(dwRetBufSize);
|
|
}
|
|
|
|
if (szRetBuffer == NULL) {
|
|
if (szTmpBuffer != NULL) MemoryFree(szTmpBuffer);
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
bReturn = FALSE;
|
|
}
|
|
else {
|
|
szNextString = (LPTSTR) ((LPBYTE) szRetBuffer + dwLastBufSize);
|
|
* szNextString = _T('\0');
|
|
}
|
|
}
|
|
|
|
if (bReturn) {
|
|
* mszLangList = szRetBuffer;
|
|
}
|
|
else {
|
|
* mszLangList = NULL;
|
|
MemoryFree(szRetBuffer);
|
|
}
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
CheckNameTable(
|
|
LPTSTR lpNameStr,
|
|
LPTSTR lpHelpStr,
|
|
LPDWORD pdwLastCounter,
|
|
LPDWORD pdwLastHelp,
|
|
BOOL bUpdate
|
|
)
|
|
{
|
|
BOOL bResult = TRUE;
|
|
BOOL bChanged = FALSE;
|
|
LPTSTR lpThisId;
|
|
DWORD dwThisId;
|
|
DWORD dwLastCounter = * pdwLastCounter;
|
|
DWORD dwLastHelp = * pdwLastHelp;
|
|
DWORD dwLastId = (dwLastCounter > dwLastHelp)
|
|
? (dwLastCounter) : (dwLastHelp);
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
0,
|
|
ERROR_SUCCESS,
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
for (lpThisId = lpNameStr;
|
|
* lpThisId;
|
|
lpThisId += (lstrlen(lpThisId) + 1)) {
|
|
dwThisId = _tcstoul(lpThisId, NULL, 10);
|
|
if ((dwThisId == 0) || (dwThisId != 1 && dwThisId % 2 != 0)) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_COUNTER_STRINGS_CORRUPT,
|
|
4, dwThisId, dwLastCounter, dwLastId, __LINE__,
|
|
1, lpThisId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpThisId),
|
|
TRACE_DWORD(dwThisId),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
SetLastError(ERROR_BADKEY);
|
|
bResult = FALSE;
|
|
break;
|
|
}
|
|
else if (dwThisId > dwLastId || dwThisId > dwLastCounter) {
|
|
if (bUpdate) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_COUNTER_STRINGS_CORRUPT,
|
|
4, dwThisId, dwLastCounter, dwLastId, __LINE__,
|
|
1, lpThisId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpThisId),
|
|
TRACE_DWORD(dwThisId),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
SetLastError(ERROR_BADKEY);
|
|
bResult = FALSE;
|
|
break;
|
|
}
|
|
else {
|
|
bChanged = TRUE;
|
|
if (dwThisId > dwLastCounter) dwLastCounter = dwThisId;
|
|
if (dwLastCounter > dwLastId) dwLastId = dwLastCounter;
|
|
}
|
|
}
|
|
|
|
lpThisId += (lstrlen(lpThisId) + 1);
|
|
}
|
|
|
|
if (! bResult) goto Cleanup;
|
|
|
|
for (lpThisId = lpHelpStr;
|
|
* lpThisId;
|
|
lpThisId += (lstrlen(lpThisId) + 1)) {
|
|
|
|
dwThisId = _tcstoul(lpThisId, NULL, 10);
|
|
if ((dwThisId == 0) || (dwThisId != 1 && dwThisId % 2 == 0)) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_HELP_STRINGS_CORRUPT,
|
|
4, dwThisId, dwLastHelp, dwLastId, __LINE__,
|
|
1, lpThisId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpThisId),
|
|
TRACE_DWORD(dwThisId),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
SetLastError(ERROR_BADKEY);
|
|
bResult = FALSE;
|
|
break;
|
|
}
|
|
else if (dwThisId > dwLastId || dwThisId > dwLastHelp) {
|
|
if (bUpdate) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_HELP_STRINGS_CORRUPT,
|
|
4, dwThisId, dwLastHelp, dwLastId, __LINE__,
|
|
1, lpThisId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_BADKEY,
|
|
TRACE_WSTR(lpThisId),
|
|
TRACE_DWORD(dwThisId),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
SetLastError(ERROR_BADKEY);
|
|
bResult = FALSE;
|
|
break;
|
|
}
|
|
else {
|
|
bChanged = TRUE;
|
|
if (dwThisId > dwLastHelp) dwLastHelp = dwThisId;
|
|
if (dwLastHelp > dwLastId) dwLastId = dwLastHelp;
|
|
}
|
|
}
|
|
lpThisId += (lstrlen(lpThisId) + 1);
|
|
}
|
|
|
|
Cleanup:
|
|
if (bResult) {
|
|
if (bChanged) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE,
|
|
(DWORD) LDPRFMSG_CORRUPT_PERFLIB_INDEX,
|
|
4, * pdwLastCounter, * pdwLastHelp, dwLastCounter, dwLastHelp,
|
|
0, NULL, NULL, NULL);
|
|
* pdwLastCounter = dwLastCounter;
|
|
* pdwLastHelp = dwLastHelp;
|
|
}
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_CHECKNAMETABLE,
|
|
0,
|
|
GetLastError(),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
UpdateEachLanguage (
|
|
HKEY hPerflibRoot,
|
|
LPWSTR mszInstalledLangList,
|
|
LPDWORD pdwLastCounter,
|
|
LPDWORD pdwLastHelp,
|
|
PLANGUAGE_LIST_ELEMENT pFirstLang,
|
|
BOOL bUpdate
|
|
)
|
|
/*++
|
|
|
|
UpdateEachLanguage
|
|
|
|
Goes through list of languages and adds the sorted MULTI_SZ strings
|
|
to the existing counter and explain text in the registry.
|
|
Also updates the "Last Counter and Last Help" values
|
|
|
|
Arguments
|
|
|
|
hPerflibRoot handle to Perflib key in the registry
|
|
|
|
mszInstalledLangList
|
|
MSZ string of installed language keys
|
|
|
|
pFirstLanguage pointer to first language entry
|
|
|
|
Return Value
|
|
|
|
TRUE all went as planned
|
|
FALSE an error occured, use GetLastError to find out what it was.
|
|
|
|
--*/
|
|
{
|
|
|
|
PLANGUAGE_LIST_ELEMENT pThisLang;
|
|
|
|
LPTSTR pHelpBuffer = NULL;
|
|
LPTSTR pNameBuffer = NULL;
|
|
LPTSTR pNewName = NULL;
|
|
LPTSTR pNewHelp = NULL;
|
|
DWORD dwLastCounter = * pdwLastCounter;
|
|
DWORD dwLastHelp = * pdwLastHelp;
|
|
DWORD dwBufferSize;
|
|
DWORD dwValueType;
|
|
DWORD dwCounterSize;
|
|
DWORD dwHelpSize;
|
|
HKEY hKeyThisLang;
|
|
LONG lStatus;
|
|
TCHAR CounterNameBuffer [20];
|
|
TCHAR HelpNameBuffer [20];
|
|
TCHAR AddCounterNameBuffer [20];
|
|
TCHAR AddHelpNameBuffer [20];
|
|
LPTSTR szThisLang;
|
|
BOOL bResult = TRUE;
|
|
|
|
if (bUpdate && dwSystemVersion != OLD_VERSION) {
|
|
// this isn't possible on 3.1
|
|
MakeBackupCopyOfLanguageFiles(NULL);
|
|
}
|
|
|
|
for (szThisLang = mszInstalledLangList;
|
|
*szThisLang != 0;
|
|
szThisLang += (lstrlen(szThisLang) + 1)) {
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(szThisLang),
|
|
NULL));
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// Open key for this language
|
|
lStatus = RegOpenKeyEx(
|
|
hPerflibRoot,
|
|
szThisLang,
|
|
RESERVED,
|
|
KEY_READ | KEY_WRITE,
|
|
& hKeyThisLang);
|
|
} else {
|
|
lstrcpy(CounterNameBuffer, CounterNameStr);
|
|
lstrcat(CounterNameBuffer, szThisLang);
|
|
lstrcpy(HelpNameBuffer, HelpNameStr);
|
|
lstrcat(HelpNameBuffer, szThisLang);
|
|
lstrcpy(AddCounterNameBuffer, AddCounterNameStr);
|
|
lstrcat(AddCounterNameBuffer, szThisLang);
|
|
lstrcpy(AddHelpNameBuffer, AddHelpNameStr);
|
|
lstrcat(AddHelpNameBuffer, szThisLang);
|
|
|
|
// make sure this language is loaded
|
|
__try {
|
|
lStatus = RegOpenKeyEx(
|
|
hPerflibRoot,
|
|
szThisLang,
|
|
RESERVED,
|
|
KEY_READ,
|
|
& hKeyThisLang);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(szThisLang),
|
|
NULL));
|
|
}
|
|
|
|
// we just need the open status, not the key handle so
|
|
// close this handle and set the one we need.
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
RegCloseKey (hKeyThisLang);
|
|
}
|
|
hKeyThisLang = hPerfData;
|
|
}
|
|
|
|
if (bUpdate) {
|
|
// look up the new strings to add
|
|
pThisLang = FindLanguage(pFirstLang, szThisLang);
|
|
if (pThisLang == NULL) {
|
|
// try default language if available
|
|
pThisLang = FindLanguage(pFirstLang, DefaultLangTag);
|
|
}
|
|
if (pThisLang == NULL) {
|
|
// try english language if available
|
|
pThisLang = FindLanguage(pFirstLang, DefaultLangId);
|
|
}
|
|
|
|
if (pThisLang == NULL) {
|
|
// unable to add this language so continue
|
|
lStatus = ERROR_NO_MATCH;
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
0,
|
|
lStatus,
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
}
|
|
else {
|
|
if ( pThisLang->NameBuffer == NULL
|
|
|| pThisLang->HelpBuffer == NULL) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_CORRUPT_INCLUDE_FILE, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
1, pThisLang->LangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_WARNING),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
LDPRFMSG_CORRUPT_INCLUDE_FILE,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
NULL));
|
|
lStatus = LDPRFMSG_CORRUPT_INCLUDE_FILE;
|
|
}
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
// get size of counter names
|
|
|
|
dwBufferSize = 0;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
(dwSystemVersion == OLD_VERSION) ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
if (dwSystemVersion != OLD_VERSION) {
|
|
// this means the language is not installed in the system.
|
|
continue;
|
|
}
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_COUNTER_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, szThisLang, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(szThisLang),
|
|
TRACE_WSTR(Counters),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwCounterSize = dwBufferSize;
|
|
|
|
// get size of help text
|
|
|
|
dwBufferSize = 0;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
(dwSystemVersion == OLD_VERSION) ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
NULL,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
if (dwSystemVersion != OLD_VERSION) {
|
|
// this means the language is not installed in the system.
|
|
continue;
|
|
}
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_HELP_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, szThisLang, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(szThisLang),
|
|
TRACE_WSTR(Help),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwHelpSize = dwBufferSize;
|
|
|
|
// allocate new buffers
|
|
|
|
if (bUpdate) {
|
|
dwCounterSize += pThisLang->dwNameBuffSize;
|
|
dwHelpSize += pThisLang->dwHelpBuffSize;
|
|
}
|
|
|
|
pNameBuffer = MemoryAllocate(dwCounterSize);
|
|
pHelpBuffer = MemoryAllocate(dwHelpSize);
|
|
if (!pNameBuffer || !pHelpBuffer) {
|
|
lStatus = ERROR_OUTOFMEMORY;
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
0,
|
|
ERROR_OUTOFMEMORY,
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
ZeroMemory(pNameBuffer, dwCounterSize);
|
|
ZeroMemory(pHelpBuffer, dwHelpSize);
|
|
|
|
// load current buffers into memory
|
|
|
|
// read counter names into buffer. Counter names will be stored as
|
|
// a MULTI_SZ string in the format of "###" "Name"
|
|
|
|
dwBufferSize = dwCounterSize;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
(dwSystemVersion == OLD_VERSION) ? Counters : CounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID)pNameBuffer,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_COUNTER_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, szThisLang, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(szThisLang),
|
|
TRACE_WSTR(Counters),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if (bUpdate) {
|
|
// set pointer to location in buffer where new string should be
|
|
// appended: end of buffer - 1 (second null at end of MULTI_SZ
|
|
pNewName = (LPTSTR)
|
|
((PBYTE)pNameBuffer + dwBufferSize - sizeof(TCHAR));
|
|
|
|
// adjust buffer length to take into account 2nd null from 1st
|
|
// buffer that has been overwritten
|
|
dwCounterSize -= sizeof(TCHAR);
|
|
}
|
|
|
|
// read explain text into buffer. Counter names will be stored as
|
|
// a MULTI_SZ string in the format of "###" "Text..."
|
|
dwBufferSize = dwHelpSize;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
(dwSystemVersion == OLD_VERSION) ? Help : HelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID)pHelpBuffer,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_READ_HELP_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, szThisLang, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(szThisLang),
|
|
TRACE_WSTR(Help),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if (bUpdate) {
|
|
// set pointer to location in buffer where new string should be
|
|
// appended: end of buffer - 1 (second null at end of MULTI_SZ
|
|
pNewHelp = (LPTSTR)
|
|
((PBYTE)pHelpBuffer + dwBufferSize - sizeof(TCHAR));
|
|
|
|
// adjust buffer length to take into account 2nd null from 1st
|
|
// buffer that has been overwritten
|
|
dwHelpSize -= sizeof(TCHAR);
|
|
}
|
|
|
|
if (bUpdate) {
|
|
// append new strings to end of current strings
|
|
memcpy(pNewHelp, pThisLang->HelpBuffer, pThisLang->dwHelpBuffSize);
|
|
memcpy(pNewName, pThisLang->NameBuffer, pThisLang->dwNameBuffSize);
|
|
}
|
|
|
|
if (! CheckNameTable(pNameBuffer, pHelpBuffer,
|
|
& dwLastCounter, & dwLastHelp, bUpdate)) {
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if (bUpdate) {
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
// load new strings back to the registry
|
|
lStatus = RegSetValueEx (
|
|
hKeyThisLang,
|
|
Counters,
|
|
RESERVED,
|
|
REG_MULTI_SZ,
|
|
(LPBYTE) pNameBuffer,
|
|
dwCounterSize);
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_COUNTER_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, pThisLang->LangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_WSTR(Counters),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
lStatus = RegSetValueEx (
|
|
hKeyThisLang,
|
|
Help,
|
|
RESERVED,
|
|
REG_MULTI_SZ,
|
|
(LPBYTE) pHelpBuffer,
|
|
dwHelpSize);
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_HELP_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, pThisLang->LangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_WSTR(Help),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
} else {
|
|
// write to the file thru PerfLib
|
|
dwBufferSize = dwCounterSize;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
AddCounterNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) pNameBuffer,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_COUNTER_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, pThisLang->LangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_WSTR(AddCounterNameBuffer),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
dwBufferSize = dwHelpSize;
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hKeyThisLang,
|
|
AddHelpNameBuffer,
|
|
RESERVED,
|
|
& dwValueType,
|
|
(LPVOID) pHelpBuffer,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_HELP_STRINGS, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, pThisLang->LangId, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEEACHLANGUAGE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(pThisLang->LangId),
|
|
TRACE_WSTR(AddHelpNameBuffer),
|
|
NULL));
|
|
bResult = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
}
|
|
MemoryFree(pNameBuffer);
|
|
MemoryFree(pHelpBuffer);
|
|
pNameBuffer = NULL;
|
|
pHelpBuffer = NULL;
|
|
|
|
if (dwSystemVersion == OLD_VERSION) {
|
|
RegCloseKey (hKeyThisLang);
|
|
}
|
|
} else {
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLEOPENLANG), szThisLang);
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if (! bResult) {
|
|
SetLastError(lStatus);
|
|
}
|
|
else if (! bUpdate) {
|
|
* pdwLastCounter = dwLastCounter;
|
|
* pdwLastHelp = dwLastHelp;
|
|
}
|
|
if (pNameBuffer != NULL) MemoryFree(pNameBuffer);
|
|
if (pHelpBuffer != NULL) MemoryFree(pHelpBuffer);
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
UpdateRegistry (
|
|
LPTSTR lpIniFile,
|
|
LPTSTR lpDriverName,
|
|
PLANGUAGE_LIST_ELEMENT pFirstLang,
|
|
PSYMBOL_TABLE_ENTRY pFirstSymbol,
|
|
PPERFOBJECT_LOOKUP plObjectGuidTable,
|
|
LPDWORD pdwObjectGuidTableSize,
|
|
LPDWORD pdwIndexValues
|
|
|
|
)
|
|
/*++
|
|
|
|
UpdateRegistry
|
|
|
|
- checks, and if not busy, sets the "busy" key in the registry
|
|
- Reads in the text and help definitions from the .ini file
|
|
- Reads in the current contents of the HELP and COUNTER names
|
|
- Builds a sorted MULTI_SZ struct containing the new definitions
|
|
- Appends the new MULTI_SZ to the current as read from the registry
|
|
- loads the new MULTI_SZ string into the registry
|
|
- updates the keys in the driver's entry and Perflib's entry in the
|
|
registry (e.g. first, last, etc)
|
|
- deletes the DisablePerformanceCounters value if it's present in
|
|
order to re-enable the perf counter DLL
|
|
- clears the "busy" key
|
|
|
|
Arguments
|
|
|
|
lpIniFile
|
|
pathname to .ini file conatining definitions
|
|
|
|
hKeyMachine
|
|
handle to HKEY_LOCAL_MACHINE in registry on system to
|
|
update counters for.
|
|
|
|
lpDriverName
|
|
Name of device driver to load counters for
|
|
|
|
pFirstLang
|
|
pointer to first element in language structure list
|
|
|
|
pFirstSymbol
|
|
pointer to first element in symbol definition list
|
|
|
|
|
|
Return Value
|
|
|
|
TRUE if registry updated successfully
|
|
FALSE if registry not updated
|
|
(This routine will print an error message to stdout if an error
|
|
is encountered).
|
|
|
|
--*/
|
|
{
|
|
|
|
HKEY hDriverPerf = NULL;
|
|
HKEY hPerflib = NULL;
|
|
|
|
LPTSTR lpDriverKeyPath;
|
|
HKEY hKeyMachine = NULL;
|
|
|
|
DWORD dwType;
|
|
DWORD dwSize;
|
|
|
|
DWORD dwFirstDriverCounter;
|
|
DWORD dwFirstDriverHelp;
|
|
DWORD dwLastDriverCounter;
|
|
DWORD dwLastPerflibCounter;
|
|
DWORD dwLastPerflibHelp;
|
|
DWORD dwPerflibBaseIndex;
|
|
DWORD dwLastCounter;
|
|
DWORD dwLastHelp;
|
|
|
|
BOOL bStatus;
|
|
LONG lStatus;
|
|
|
|
LPTSTR lpszObjectList = NULL;
|
|
DWORD dwObjectList = dwFileSize;
|
|
LPTSTR mszLangList = NULL;
|
|
|
|
DWORD dwWaitStatus;
|
|
HANDLE hLocalMutex = NULL;
|
|
|
|
if (LoadPerfGrabMutex() == FALSE) {
|
|
return FALSE;
|
|
}
|
|
|
|
bStatus = FALSE;
|
|
SetLastError (ERROR_SUCCESS);
|
|
|
|
// allocate temporary buffers
|
|
lpDriverKeyPath = MemoryAllocate (MAX_PATH * sizeof(TCHAR));
|
|
if (dwObjectList < MAX_PROFILE_BUFFER * sizeof(TCHAR)) {
|
|
dwObjectList = MAX_PROFILE_BUFFER * sizeof(TCHAR);
|
|
}
|
|
lpszObjectList = MemoryAllocate(dwObjectList);
|
|
if (lpDriverKeyPath == NULL || lpszObjectList == NULL) {
|
|
SetLastError (ERROR_OUTOFMEMORY);
|
|
goto UpdateRegExit;
|
|
}
|
|
ZeroMemory(lpDriverKeyPath, MAX_PATH * sizeof(TCHAR));
|
|
ZeroMemory(lpszObjectList, dwObjectList);
|
|
|
|
// build driver key path string
|
|
|
|
lstrcpy (lpDriverKeyPath, DriverPathRoot);
|
|
lstrcat (lpDriverKeyPath, Slash);
|
|
lstrcat (lpDriverKeyPath, lpDriverName);
|
|
lstrcat (lpDriverKeyPath, Slash);
|
|
lstrcat (lpDriverKeyPath, Performance);
|
|
|
|
// check if we need to connect to remote machine
|
|
if (ComputerName[0]) {
|
|
lStatus = !ERROR_SUCCESS;
|
|
try {
|
|
lStatus = RegConnectRegistry(
|
|
(LPTSTR) ComputerName,
|
|
HKEY_LOCAL_MACHINE,
|
|
& hKeyMachine);
|
|
} finally {
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
SetLastError (lStatus);
|
|
hKeyMachine = NULL;
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_CONNECT_PROBLEM),
|
|
ComputerName, lStatus);
|
|
bStatus = FALSE;
|
|
}
|
|
}
|
|
if (lStatus != ERROR_SUCCESS)
|
|
goto UpdateRegExit;
|
|
} else {
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
}
|
|
|
|
// open keys to registry
|
|
// open key to driver's performance key
|
|
|
|
__try {
|
|
lStatus = RegOpenKeyEx(
|
|
hKeyMachine,
|
|
lpDriverKeyPath,
|
|
RESERVED,
|
|
KEY_WRITE | KEY_READ,
|
|
& hDriverPerf);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_OPEN_KEY, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpDriverKeyPath, NULL, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_OPEN_DRIVERPERF1), lpDriverKeyPath);
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_OPEN_DRIVERPERF2), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(lpDriverName),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// open key to perflib's "root" key
|
|
|
|
__try {
|
|
lStatus = RegOpenKeyEx(
|
|
hKeyMachine,
|
|
NamesKey,
|
|
RESERVED,
|
|
KEY_WRITE | KEY_READ,
|
|
& hPerflib);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_OPEN_KEY, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, (LPWSTR) NamesKey, NULL, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_OPEN_PERFLIB), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(NamesKey),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// get "LastCounter" values from PERFLIB
|
|
|
|
dwType = 0;
|
|
dwLastPerflibCounter = 0;
|
|
dwSize = sizeof (dwLastPerflibCounter);
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hPerflib,
|
|
LastCounter,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwLastPerflibCounter,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// this request should always succeed, if not then worse things
|
|
// will happen later on, so quit now and avoid the trouble.
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_QUERY_VALUE, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
2, (LPWSTR) LastCounter, (LPWSTR) NamesKey, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_ERR_READLASTPERFLIB), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(LastCounter),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// get "LastHelp" value now
|
|
|
|
dwType = 0;
|
|
dwLastPerflibHelp = 0;
|
|
dwSize = sizeof (dwLastPerflibHelp);
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hPerflib,
|
|
LastHelp,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwLastPerflibHelp,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// this request should always succeed, if not then worse things
|
|
// will happen later on, so quit now and avoid the trouble.
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_QUERY_VALUE, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
2, (LPWSTR) LastHelp, (LPWSTR) NamesKey, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_ERR_READLASTPERFLIB), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(LastHelp),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// get "Base Index" value now
|
|
dwType = 0;
|
|
dwPerflibBaseIndex = 0;
|
|
dwSize = sizeof (dwPerflibBaseIndex);
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hPerflib,
|
|
szBaseIndex,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwPerflibBaseIndex,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// this request should always succeed, if not then worse things
|
|
// will happen later on, so quit now and avoid the trouble.
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_QUERY_VALUE, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
2, (LPWSTR) szBaseIndex, (LPWSTR) NamesKey, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_ERR_READLASTPERFLIB), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(szBaseIndex),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// get "Version" value now
|
|
|
|
dwType = 0;
|
|
dwSize = sizeof (dwSystemVersion);
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hPerflib,
|
|
VersionStr,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwSystemVersion,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
dwSystemVersion = OLD_VERSION;
|
|
}
|
|
|
|
|
|
// set the hPerfData to HKEY_PERFORMANCE_DATA for new version
|
|
// if remote machine, then need to connect to it.
|
|
if (dwSystemVersion != OLD_VERSION) {
|
|
hPerfData = HKEY_PERFORMANCE_DATA;
|
|
lStatus = !ERROR_SUCCESS;
|
|
if (ComputerName[0]) {
|
|
// have to do it the old faction way
|
|
dwSystemVersion = OLD_VERSION;
|
|
lStatus = ERROR_SUCCESS;
|
|
}
|
|
} // NEW_VERSION
|
|
|
|
// see if this driver's counter names have already been installed
|
|
// by checking to see if LastCounter's value is less than Perflib's
|
|
// Last Counter
|
|
|
|
dwType = 0;
|
|
dwLastDriverCounter = 0;
|
|
dwSize = sizeof (dwLastDriverCounter);
|
|
__try {
|
|
lStatus = RegQueryValueEx (
|
|
hDriverPerf,
|
|
LastCounter,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwLastDriverCounter,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
// if key found, then compare with perflib value and exit this
|
|
// procedure if the driver's last counter is <= to perflib's last
|
|
//
|
|
// if key not found, then continue with installation
|
|
// on the assumption that the counters have not been installed
|
|
|
|
if (dwLastDriverCounter <= dwLastPerflibCounter) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_ALREADY_IN), lpDriverName);
|
|
SetLastError (ERROR_ALREADY_EXISTS);
|
|
goto UpdateRegExit;
|
|
}
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpIniFile),
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_DWORD(dwLastPerflibCounter),
|
|
TRACE_DWORD(dwLastPerflibHelp),
|
|
TRACE_DWORD(dwPerflibBaseIndex),
|
|
TRACE_DWORD(dwSystemVersion),
|
|
NULL));
|
|
|
|
// set the "busy" indicator under the PERFLIB key
|
|
|
|
dwSize = lstrlen(lpDriverName) * sizeof (TCHAR);
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hPerflib,
|
|
Busy,
|
|
RESERVED,
|
|
REG_SZ,
|
|
(LPBYTE) lpDriverName,
|
|
dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_ERR_UNABLESETBUSY), lStatus);
|
|
SetLastError (lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(Busy),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
dwLastCounter = dwLastPerflibCounter;
|
|
dwLastHelp = dwLastPerflibHelp;
|
|
|
|
// get the list of installed languages on this machine
|
|
if (!GetInstalledLanguageList (hPerflib, &mszLangList)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_UPDATELANG), GetLastError());
|
|
goto UpdateRegExit;
|
|
}
|
|
if (!UpdateEachLanguage(hPerflib,
|
|
mszLangList,
|
|
& dwLastCounter,
|
|
& dwLastHelp,
|
|
pFirstLang,
|
|
FALSE)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_UPDATELANG), GetLastError());
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
|
|
// increment (by 2) the last counters so they point to the first
|
|
// unused index after the existing names and then
|
|
// set the first driver counters
|
|
|
|
dwFirstDriverCounter = dwLastCounter + 2;
|
|
dwFirstDriverHelp = dwLastHelp + 2;
|
|
|
|
if ( (dwPerflibBaseIndex < PERFLIB_BASE_INDEX)
|
|
|| (dwFirstDriverCounter < dwPerflibBaseIndex)
|
|
|| (dwFirstDriverHelp < dwPerflibBaseIndex)) {
|
|
// potential CounterIndex/HelpIndex overlap with Base counters,
|
|
//
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_BASEINDEX_CORRUPT, // event,
|
|
4, dwPerflibBaseIndex, dwFirstDriverCounter, dwFirstDriverHelp, __LINE__,
|
|
1, lpDriverName, NULL, NULL);
|
|
lStatus = ERROR_BADKEY;
|
|
SetLastError(lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_DWORD(dwPerflibBaseIndex),
|
|
TRACE_DWORD(dwFirstDriverCounter),
|
|
TRACE_DWORD(dwFirstDriverHelp),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// load .INI file definitions into language tables
|
|
|
|
if (!LoadLanguageLists (lpIniFile, dwFirstDriverCounter , dwFirstDriverHelp,
|
|
pFirstSymbol, pFirstLang)) {
|
|
// error message is displayed by LoadLanguageLists so just abort
|
|
// error is in GetLastError already
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
if (!CreateObjectList (lpIniFile, dwFirstDriverCounter, pFirstSymbol,
|
|
lpszObjectList, plObjectGuidTable, pdwObjectGuidTableSize)) {
|
|
// error message is displayed by CreateObjectList so just abort
|
|
// error is in GetLastError already
|
|
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// all the symbols and definitions have been loaded into internal
|
|
// tables. so now they need to be sorted and merged into a multiSZ string
|
|
// this routine also updates the "last" counters
|
|
|
|
if (!SortLanguageTables (pFirstLang, &dwLastCounter, &dwLastHelp)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_UNABLESORTTABLES), GetLastError());
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
if ( (dwLastCounter < dwLastPerflibCounter)
|
|
|| (dwLastHelp < dwLastPerflibHelp)) {
|
|
// potential CounterIndex/HelpIndex overlap with Base counters,
|
|
//
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_REGISTRY_BASEINDEX_CORRUPT, // event,
|
|
4, dwLastPerflibCounter, dwLastCounter, dwLastHelp, __LINE__,
|
|
1 , lpDriverName, NULL, NULL);
|
|
lStatus = ERROR_BADKEY;
|
|
SetLastError(lStatus);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_DWORD(dwLastPerflibCounter),
|
|
TRACE_DWORD(dwLastPerflibHelp),
|
|
TRACE_DWORD(dwLastCounter),
|
|
TRACE_DWORD(dwLastHelp),
|
|
NULL));
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
if (!UpdateEachLanguage(hPerflib,
|
|
mszLangList,
|
|
& dwLastCounter,
|
|
& dwLastHelp,
|
|
pFirstLang,
|
|
TRUE)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_ERR_UPDATELANG), GetLastError());
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
dwLastPerflibCounter = dwLastCounter;
|
|
dwLastPerflibHelp = dwLastHelp;
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_DWORD(dwFirstDriverCounter),
|
|
TRACE_DWORD(dwFirstDriverHelp),
|
|
TRACE_DWORD(dwLastPerflibCounter),
|
|
TRACE_DWORD(dwLastPerflibHelp),
|
|
NULL));
|
|
|
|
if (dwLastCounter < dwFirstDriverCounter) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_CORRUPT_INDEX_RANGE, // event,
|
|
3, dwFirstDriverCounter, dwLastCounter, __LINE__, 0,
|
|
2, (LPWSTR) Counters, (LPWSTR) lpDriverKeyPath, NULL);
|
|
goto UpdateRegExit;
|
|
}
|
|
if (dwLastHelp < dwFirstDriverHelp) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_CORRUPT_INDEX_RANGE, // event,
|
|
3, dwFirstDriverHelp, dwLastHelp, __LINE__, 0,
|
|
2, (LPWSTR) Help, (LPWSTR) lpDriverKeyPath, NULL);
|
|
goto UpdateRegExit;
|
|
}
|
|
|
|
// update last counters for driver and perflib
|
|
|
|
// perflib...
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hPerflib,
|
|
LastCounter,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwLastPerflibCounter,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwLastPerflibCounter, __LINE__, 0,
|
|
2, (LPWSTR) LastCounter, (LPWSTR) NamesKey, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
LastCounter, szPerflib);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(LastCounter),
|
|
TRACE_DWORD(dwLastPerflibCounter),
|
|
NULL));
|
|
}
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hPerflib,
|
|
LastHelp,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwLastPerflibHelp,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwLastPerflibHelp, __LINE__, 0,
|
|
2, (LPWSTR) LastHelp, (LPWSTR) NamesKey, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
LastHelp, szPerflib);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(NamesKey),
|
|
TRACE_WSTR(LastHelp),
|
|
TRACE_DWORD(dwLastPerflibHelp),
|
|
NULL));
|
|
}
|
|
|
|
// and the driver
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hDriverPerf,
|
|
LastCounter,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwLastPerflibCounter,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwLastPerflibCounter, __LINE__, 0,
|
|
2, (LPWSTR) LastCounter, (LPWSTR) lpDriverKeyPath, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
LastCounter, lpDriverName);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(LastCounter),
|
|
TRACE_DWORD(dwLastPerflibCounter),
|
|
NULL));
|
|
}
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hDriverPerf,
|
|
LastHelp,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwLastPerflibHelp,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwLastPerflibHelp, __LINE__, 0,
|
|
2, (LPWSTR) LastHelp, (LPWSTR) lpDriverKeyPath, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
LastHelp, lpDriverName);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(LastHelp),
|
|
TRACE_DWORD(dwLastPerflibHelp),
|
|
NULL));
|
|
}
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hDriverPerf,
|
|
cszFirstCounter,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwFirstDriverCounter,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwFirstDriverCounter, __LINE__, 0,
|
|
2, (LPWSTR) cszFirstCounter, (LPWSTR) lpDriverKeyPath, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
cszFirstCounter, lpDriverName);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(cszFirstCounter),
|
|
TRACE_DWORD(dwFirstDriverCounter),
|
|
NULL));
|
|
}
|
|
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hDriverPerf,
|
|
FirstHelp,
|
|
RESERVED,
|
|
REG_DWORD,
|
|
(LPBYTE) & dwFirstDriverHelp,
|
|
sizeof(DWORD));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
3, lStatus, dwFirstDriverHelp, __LINE__, 0,
|
|
2, (LPWSTR) FirstHelp, (LPWSTR) lpDriverKeyPath, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
FirstHelp, lpDriverName);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(FirstHelp),
|
|
TRACE_DWORD(dwFirstDriverHelp),
|
|
NULL));
|
|
}
|
|
|
|
if (*lpszObjectList != 0) {
|
|
__try {
|
|
lStatus = RegSetValueEx(
|
|
hDriverPerf,
|
|
szObjectList,
|
|
RESERVED,
|
|
REG_SZ,
|
|
(LPBYTE) lpszObjectList,
|
|
(lstrlen(lpszObjectList) + 1) * sizeof (TCHAR));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_UPDATE_VALUE, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
2, (LPWSTR) szObjectList, (LPWSTR) lpDriverKeyPath, NULL);
|
|
OUTPUT_MESSAGE (GetFormatResource (LC_UNABLESETVALUE),
|
|
szObjectList, lpDriverName);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEREGISTRY,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(szObjectList),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
bStatus = TRUE;
|
|
|
|
pdwIndexValues[0] = dwFirstDriverCounter; // first Counter
|
|
pdwIndexValues[1] = dwLastPerflibCounter; // last Counter
|
|
pdwIndexValues[2] = dwFirstDriverHelp; // first Help
|
|
pdwIndexValues[3] = dwLastPerflibHelp; // last Help
|
|
|
|
// remove "DisablePerformanceCounter" value so perf counters are re-enabled.
|
|
lStatus = RegDeleteValue (hDriverPerf, szDisablePerformanceCounters);
|
|
|
|
// MemoryFree temporary buffers
|
|
UpdateRegExit:
|
|
// clear busy flag
|
|
|
|
if (hPerflib) {
|
|
lStatus = RegDeleteValue (
|
|
hPerflib,
|
|
Busy);
|
|
}
|
|
|
|
ReleaseMutex(hLoadPerfMutex);
|
|
|
|
// MemoryFree temporary buffers
|
|
|
|
// free any guid string buffers here
|
|
// TODO: add this code
|
|
|
|
if (lpDriverKeyPath) MemoryFree (lpDriverKeyPath);
|
|
if (lpszObjectList) MemoryFree (lpszObjectList);
|
|
if (hDriverPerf) RegCloseKey (hDriverPerf);
|
|
if (hPerflib) RegCloseKey (hPerflib);
|
|
|
|
if (mszLangList != NULL) MemoryFree(mszLangList);
|
|
|
|
if (hPerfData && hPerfData != HKEY_PERFORMANCE_DATA) {
|
|
RegCloseKey (hPerfData);
|
|
}
|
|
|
|
if (hKeyMachine && hKeyMachine != HKEY_LOCAL_MACHINE) {
|
|
RegCloseKey (hKeyMachine) ;
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
DWORD
|
|
GetMofFileFromIni (
|
|
LPCWSTR lpIniFile,
|
|
LPWSTR MofFilename
|
|
)
|
|
{
|
|
DWORD dwRetSize;
|
|
DWORD dwReturn = ERROR_SUCCESS;
|
|
|
|
if (MofFilename) {
|
|
dwRetSize = GetPrivateProfileString (
|
|
szInfo, // info section
|
|
szMofFileName, // Mof Filename value
|
|
szNotFound, // default value
|
|
MofFilename, // output buffer
|
|
MAX_PATH, // buffer size
|
|
lpIniFile); // ini file to read
|
|
|
|
if ((lstrcmpi(MofFilename, szNotFound)) != 0) {
|
|
// name found
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_GETMOFFILEFROMINI,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
dwReturn,
|
|
TRACE_WSTR(MofFilename),
|
|
NULL));
|
|
} else {
|
|
// name not found, default returned so return NULL string
|
|
MofFilename[0] = 0;
|
|
dwReturn = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
} else {
|
|
dwReturn = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (dwReturn != ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_GETMOFFILEFROMINI, 0, dwReturn, NULL));
|
|
}
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
DWORD
|
|
OpenCounterAndBuildMofFile (
|
|
LPCWSTR lpDriverName,
|
|
LPCWSTR MofFilename,
|
|
PPERFOBJECT_LOOKUP plObjectGuidTable,
|
|
DWORD dwObjectGuidTableSize
|
|
)
|
|
{
|
|
DWORD dwType;
|
|
DWORD dwSize;
|
|
HKEY hKeyMachine = NULL;
|
|
HKEY hDriverPerf = NULL;
|
|
LONG lStatus = ERROR_SUCCESS;
|
|
LPWSTR *lpCounterText;
|
|
LPWSTR *lpDisplayText = NULL; // Localized name strings array
|
|
DWORD dwLastElement;
|
|
WCHAR lpDriverKeyPath[MAX_PATH];
|
|
WCHAR wszPerfLibraryName[MAX_PATH];
|
|
WCHAR wszLibraryExpPath[MAX_PATH];
|
|
WCHAR szProviderName[MAX_PATH];
|
|
DWORD dwProviderNameSize;
|
|
HANDLE hPerfLibrary = NULL;
|
|
CHAR szOpenProcName[MAX_PATH];
|
|
PM_OPEN_PROC *pOpenProc = NULL;
|
|
CHAR szCollectProcName[MAX_PATH];
|
|
PM_COLLECT_PROC *pCollectProc = NULL;
|
|
CHAR szCloseProcName[MAX_PATH];
|
|
PM_CLOSE_PROC *pCloseProc = NULL;
|
|
LPBYTE pPerfBuffer = NULL;
|
|
LPBYTE pPerfBufferArg;
|
|
DWORD dwPerfBufferSize;
|
|
DWORD dwThisObject;
|
|
DWORD dwThisCounterDef;
|
|
WCHAR szMofBuffer[8192*2];
|
|
DWORD dwMofBufferSize;
|
|
HANDLE hMofFile;
|
|
PERF_COUNTER_DLL_INFO PcDllInfo;
|
|
DWORD dwGuidIdx;
|
|
WCHAR wszLocalLang[8];
|
|
|
|
PPERF_OBJECT_TYPE pThisObject;
|
|
PPERF_COUNTER_DEFINITION pThisCounterDef;
|
|
|
|
// get registry key for this object
|
|
// build driver key path string
|
|
|
|
lstrcpy (lpDriverKeyPath, DriverPathRoot);
|
|
lstrcat (lpDriverKeyPath, Slash);
|
|
lstrcat (lpDriverKeyPath, lpDriverName);
|
|
lstrcat (lpDriverKeyPath, Slash);
|
|
lstrcat (lpDriverKeyPath, Performance);
|
|
|
|
// check if we need to connect to remote machine
|
|
|
|
if (ComputerName[0]) {
|
|
lStatus = !ERROR_SUCCESS;
|
|
try {
|
|
lStatus = RegConnectRegistry (
|
|
(LPTSTR)ComputerName,
|
|
HKEY_LOCAL_MACHINE,
|
|
& hKeyMachine);
|
|
} finally {
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
hKeyMachine = NULL;
|
|
}
|
|
}
|
|
} else {
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
}
|
|
|
|
// bail out here if unable to open the registry
|
|
if (hKeyMachine == NULL) return lStatus;
|
|
|
|
// get ENGLISH string list
|
|
lpCounterText = BuildNameTable (
|
|
hKeyMachine,
|
|
(LPWSTR)L"009", // Use english as the language entry for WBEM
|
|
&dwLastElement);
|
|
|
|
if (lpCounterText == NULL) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get LOCAL strings
|
|
// get locale and convert to string first
|
|
memset (wszLocalLang, 0, sizeof(wszLocalLang));
|
|
swprintf (wszLocalLang, (LPCWSTR)L"0%2.2x", (GetSystemDefaultLCID() & 0x000000FF));
|
|
|
|
lpDisplayText = BuildNameTable (
|
|
hKeyMachine,
|
|
(LPWSTR)wszLocalLang, // Use local language for strings
|
|
&dwLastElement);
|
|
|
|
if (lpDisplayText == NULL) {
|
|
|
|
lpDisplayText = BuildNameTable (
|
|
hKeyMachine,
|
|
(LPWSTR)L"009", // then Use english
|
|
&dwLastElement);
|
|
|
|
if (lpDisplayText == NULL) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
}
|
|
|
|
// open key to driver's performance key
|
|
|
|
__try {
|
|
lStatus = RegOpenKeyEx (
|
|
hKeyMachine,
|
|
lpDriverKeyPath,
|
|
RESERVED,
|
|
KEY_WRITE | KEY_READ,
|
|
& hDriverPerf);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_UNABLE_OPEN_KEY, // event,
|
|
2, lStatus, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpDriverKeyPath, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get library name
|
|
dwType = 0;
|
|
dwSize = sizeof(wszPerfLibraryName);
|
|
__try {
|
|
lStatus = RegQueryValueExW (hDriverPerf,
|
|
cszLibrary,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & wszPerfLibraryName[0],
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
if (dwType == REG_EXPAND_SZ) {
|
|
// expand any environment vars
|
|
dwSize = ExpandEnvironmentStringsW(
|
|
wszPerfLibraryName,
|
|
wszLibraryExpPath,
|
|
MAX_PATH);
|
|
|
|
if ((dwSize > MAX_PATH) || (dwSize == 0)) {
|
|
lStatus = ERROR_INVALID_DLL;
|
|
}
|
|
} else if (dwType == REG_SZ) {
|
|
// look for dll and save full file Path
|
|
dwSize = SearchPathW (
|
|
NULL, // use standard system search path
|
|
wszPerfLibraryName,
|
|
NULL,
|
|
MAX_PATH,
|
|
wszLibraryExpPath,
|
|
NULL);
|
|
|
|
if ((dwSize > MAX_PATH) || (dwSize == 0)) {
|
|
lStatus = ERROR_INVALID_DLL;
|
|
}
|
|
} else {
|
|
lStatus = ERROR_INVALID_DLL;
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(wszPerfLibraryName),
|
|
NULL));
|
|
}
|
|
}
|
|
else {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(cszLibrary),
|
|
NULL));
|
|
}
|
|
|
|
// unable to continue if error
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get open procedure name
|
|
dwType = 0;
|
|
dwSize = sizeof(szOpenProcName);
|
|
__try {
|
|
lStatus = RegQueryValueExA (hDriverPerf,
|
|
caszOpen,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & szOpenProcName[0],
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
// unable to continue if error
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(caszOpen),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get collect procedure name
|
|
dwType = 0;
|
|
dwSize = sizeof(szCollectProcName);
|
|
__try {
|
|
lStatus = RegQueryValueExA (hDriverPerf,
|
|
caszCollect,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & szCollectProcName[0],
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
// unable to continue if error
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(caszCollect),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get close procedure name
|
|
dwType = 0;
|
|
dwSize = sizeof(szCloseProcName);
|
|
__try {
|
|
lStatus = RegQueryValueExA (hDriverPerf,
|
|
caszClose,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & szCloseProcName[0],
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
// unable to continue if error
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(caszClose),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// load perf counter library
|
|
hPerfLibrary = LoadLibraryW (wszPerfLibraryName);
|
|
if (hPerfLibrary == NULL) {
|
|
lStatus = GetLastError();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(wszPerfLibraryName),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get open procedure pointer
|
|
pOpenProc = (PM_OPEN_PROC *) GetProcAddress (
|
|
hPerfLibrary,
|
|
szOpenProcName);
|
|
|
|
if (pOpenProc == NULL) {
|
|
lStatus = GetLastError();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(szOpenProcName),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get collect procedure pointer
|
|
pCollectProc = (PM_COLLECT_PROC *) GetProcAddress (
|
|
hPerfLibrary,
|
|
szCollectProcName);
|
|
|
|
if (pCollectProc == NULL) {
|
|
lStatus = GetLastError();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(szCollectProcName),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// get close procedure pointer
|
|
pCloseProc = (PM_CLOSE_PROC *) GetProcAddress (
|
|
hPerfLibrary,
|
|
szCloseProcName);
|
|
|
|
if (pCloseProc == NULL) {
|
|
lStatus = GetLastError();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_STR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_STR(szCloseProcName),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// call open procedure to initialize the counter
|
|
__try {
|
|
lStatus = (*pOpenProc)((LPWSTR)L"");
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
// unable to continue if error
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
dwPerfBufferSize = 0;
|
|
// call the collect function to get a buffer
|
|
do {
|
|
// allocate a query buffer to pass to the collect function
|
|
dwPerfBufferSize += 0x8000;
|
|
if (pPerfBuffer == NULL) {
|
|
pPerfBuffer = (LPBYTE) MemoryAllocate (dwPerfBufferSize);
|
|
} else {
|
|
// if buffer is too small, resize and try again
|
|
pPerfBuffer = (LPBYTE) MemoryResize (pPerfBuffer, dwPerfBufferSize);
|
|
}
|
|
|
|
if (pPerfBuffer == NULL) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
dwSize = dwPerfBufferSize;
|
|
dwType = 0; // count of object types
|
|
pPerfBufferArg = pPerfBuffer;
|
|
lStatus = (* pCollectProc) (
|
|
(LPWSTR)L"Global",
|
|
&pPerfBufferArg,
|
|
&dwSize,
|
|
&dwType);
|
|
|
|
} while (lStatus == ERROR_MORE_DATA);
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
// create temporary file for writing the MOF to
|
|
|
|
hMofFile = CreateFileW (
|
|
MofFilename,
|
|
GENERIC_WRITE,
|
|
0, // no sharing
|
|
NULL, // default security
|
|
CREATE_ALWAYS, // always start fresh
|
|
FILE_ATTRIBUTE_NORMAL, // nothing special
|
|
NULL); // no template
|
|
|
|
if (hMofFile == INVALID_HANDLE_VALUE) {
|
|
// unable to create MOF file
|
|
lStatus = GetLastError();
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(MofFilename),
|
|
NULL));
|
|
goto MakeMofErrorExit;
|
|
}
|
|
|
|
lstrcpyW (szProviderName, wszPerfLibraryName);
|
|
dwProviderNameSize = (sizeof(szProviderName) / sizeof(szProviderName[0]));
|
|
dwMofBufferSize = (sizeof(szMofBuffer) / sizeof(szMofBuffer[0]));
|
|
lStatus = GenerateMofHeader (szMofBuffer, (LPTSTR)ComputerName, &dwMofBufferSize);
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
lStatus = WriteWideStringToAnsiFile (hMofFile, szMofBuffer, &dwMofBufferSize);
|
|
}
|
|
|
|
PcDllInfo.szWbemProviderName = szProviderName;
|
|
PcDllInfo.szRegistryKey = (LPWSTR)lpDriverName;
|
|
|
|
// for each object returned
|
|
pThisObject = (PPERF_OBJECT_TYPE)pPerfBuffer;
|
|
for (dwThisObject = 0; dwThisObject < dwType; dwThisObject++) {
|
|
PcDllInfo.szClassGuid = (LPWSTR)L"";
|
|
// look up class guid string in table passed in
|
|
if (plObjectGuidTable != NULL) {
|
|
dwGuidIdx = 0;
|
|
while (dwGuidIdx < dwObjectGuidTableSize) {
|
|
if (pThisObject->ObjectNameTitleIndex == (DWORD)plObjectGuidTable[dwGuidIdx].PerfObjectId) {
|
|
PcDllInfo.szClassGuid = plObjectGuidTable[dwGuidIdx].GuidString;
|
|
break;
|
|
}
|
|
dwGuidIdx++;
|
|
}
|
|
}
|
|
if (PcDllInfo.szClassGuid[0] == 0) {
|
|
// try the standard list
|
|
PcDllInfo.szClassGuid = (LPWSTR)GetPerfObjectGuid (pThisObject->ObjectNameTitleIndex);
|
|
} else {
|
|
// just leave it blank
|
|
}
|
|
// create WBEM Class object for this perf object
|
|
dwMofBufferSize = (sizeof(szMofBuffer) / sizeof(szMofBuffer[0]));
|
|
lStatus = GenerateMofObject (szMofBuffer, &dwMofBufferSize,
|
|
&PcDllInfo,
|
|
pThisObject, lpCounterText, lpDisplayText, WM_GMO_RAW_DEFINITION);
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
lStatus = WriteWideStringToAnsiFile (
|
|
hMofFile, szMofBuffer, &dwMofBufferSize);
|
|
}
|
|
// for each counter defined in this object
|
|
pThisCounterDef = FirstCounter (pThisObject);
|
|
for (dwThisCounterDef = 0;
|
|
dwThisCounterDef < pThisObject->NumCounters;
|
|
dwThisCounterDef++) {
|
|
// define a WBEM property
|
|
dwMofBufferSize = (sizeof(szMofBuffer) / sizeof(szMofBuffer[0]));
|
|
lStatus = GenerateMofCounter (szMofBuffer, &dwMofBufferSize,
|
|
pThisCounterDef, lpCounterText,lpDisplayText, WM_GMO_RAW_DEFINITION);
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
lStatus = WriteWideStringToAnsiFile (
|
|
hMofFile, szMofBuffer, &dwMofBufferSize);
|
|
}
|
|
|
|
pThisCounterDef = NextCounter (pThisCounterDef);
|
|
}
|
|
dwMofBufferSize = (sizeof(szMofBuffer) / sizeof(szMofBuffer[0]));
|
|
lStatus = GenerateMofObjectTail (szMofBuffer, &dwMofBufferSize);
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
lStatus = WriteWideStringToAnsiFile (
|
|
hMofFile, szMofBuffer, &dwMofBufferSize);
|
|
}
|
|
}
|
|
|
|
// end for each object
|
|
pThisObject = NextObject (pThisObject);
|
|
}
|
|
|
|
// write end of file
|
|
SetEndOfFile(hMofFile);
|
|
CloseHandle(hMofFile);
|
|
// call close proc
|
|
|
|
lStatus = (* pCloseProc)();
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_OPENCOUNTERANDBUILDMOFFILE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2) |
|
|
ARG_DEF(ARG_TYPE_WSTR, 3) | ARG_DEF(ARG_TYPE_STR, 4) |
|
|
ARG_DEF(ARG_TYPE_STR, 5) | ARG_DEF(ARG_TYPE_STR, 6),
|
|
lStatus,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(MofFilename),
|
|
TRACE_WSTR(wszPerfLibraryName),
|
|
TRACE_STR(szOpenProcName),
|
|
TRACE_STR(szCollectProcName),
|
|
TRACE_STR(szCloseProcName),
|
|
NULL));
|
|
|
|
MakeMofErrorExit:
|
|
// close the registry key if necessary
|
|
if ((hKeyMachine != HKEY_LOCAL_MACHINE) &&
|
|
(hKeyMachine != NULL)) {
|
|
RegCloseKey (hKeyMachine);
|
|
}
|
|
|
|
if (hDriverPerf != NULL) RegCloseKey (hDriverPerf);
|
|
|
|
if (lpCounterText == NULL) MemoryFree (lpCounterText);
|
|
if (lpDisplayText == NULL) MemoryFree (lpDisplayText);
|
|
|
|
// MemoryFree perf counter library
|
|
if (hPerfLibrary != NULL) FreeLibrary (hPerfLibrary);
|
|
|
|
// MemoryFree the collection buffer
|
|
if (pPerfBuffer != NULL) MemoryFree (pPerfBuffer);
|
|
|
|
// return
|
|
return (DWORD)lStatus;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
InstallPerfDllW (
|
|
IN LPCWSTR szComputerName,
|
|
IN LPCWSTR lpIniFile,
|
|
IN ULONG_PTR dwFlags
|
|
)
|
|
{
|
|
LPWSTR lpDriverName = NULL;
|
|
WCHAR MofFilename[MAX_PATH];
|
|
PERFOBJECT_LOOKUP plObjectGuidTable[16];
|
|
DWORD dwObjectGuidTableSize;
|
|
DWORD dwObjectIndex;
|
|
LANGUAGE_LIST_ELEMENT LangList;
|
|
PSYMBOL_TABLE_ENTRY SymbolTable = NULL;
|
|
DWORD ErrorCode = ERROR_SUCCESS;
|
|
DWORD dwIndexValues[4] = {0,0,0,0};
|
|
HKEY hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
HKEY hKeyDriver = NULL;
|
|
|
|
WinPerfStartTrace(NULL);
|
|
bQuietMode = (BOOL)((dwFlags & LOADPERF_FLAGS_DISPLAY_USER_MSGS) == 0);
|
|
|
|
// initialize the object GUID table
|
|
memset (plObjectGuidTable, 0, sizeof (plObjectGuidTable));
|
|
dwObjectGuidTableSize = sizeof (plObjectGuidTable) / sizeof (plObjectGuidTable[0]) ;
|
|
|
|
if (szComputerName == NULL) {
|
|
ComputerName[0] = 0; // use the local computer
|
|
} else {
|
|
if (lstrlenW(szComputerName) < FILE_NAME_BUFFER_SIZE) {
|
|
lstrcpyW (ComputerName, szComputerName);
|
|
} else {
|
|
ErrorCode = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
if ((lpIniFile != NULL) && (ErrorCode == ERROR_SUCCESS)) {
|
|
lpDriverName = MemoryAllocate (MAX_PATH * sizeof (WCHAR));
|
|
if (lpDriverName == NULL) {
|
|
ErrorCode = ERROR_OUTOFMEMORY;
|
|
goto EndOfMain;
|
|
}
|
|
|
|
// valid filename (i.e. file exists)
|
|
// get device driver name
|
|
|
|
if (!GetDriverName ((LPWSTR)lpIniFile, &lpDriverName)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_DEVNAME_ERR_1), lpIniFile);
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_DEVNAME_ERR_2));
|
|
ErrorCode = GetLastError();
|
|
MemoryFree(lpDriverName);
|
|
lpDriverName = NULL;
|
|
goto EndOfMain;
|
|
}
|
|
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
if (ComputerName[0]) {
|
|
ErrorCode = RegConnectRegistry (
|
|
(LPTSTR) ComputerName,
|
|
HKEY_LOCAL_MACHINE,
|
|
& hKeyMachine);
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
hKeyMachine = HKEY_LOCAL_MACHINE;
|
|
}
|
|
}
|
|
RtlZeroMemory(szServiceDisplayName, MAX_PATH * sizeof(TCHAR));
|
|
RtlZeroMemory(szServiceName, MAX_PATH * sizeof(TCHAR));
|
|
lstrcpy(szServiceName, DriverPathRoot);
|
|
lstrcat(szServiceName, Slash);
|
|
lstrcat(szServiceName, lpDriverName);
|
|
ErrorCode = RegOpenKeyEx(hKeyMachine,
|
|
szServiceName,
|
|
RESERVED,
|
|
KEY_READ | KEY_WRITE,
|
|
& hKeyDriver);
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
DWORD dwType = 0;
|
|
DWORD dwBufferSize = MAX_PATH * sizeof(TCHAR);
|
|
__try {
|
|
ErrorCode = RegQueryValueEx(hKeyDriver,
|
|
szDisplayName,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) szServiceDisplayName,
|
|
& dwBufferSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
ErrorCode = GetExceptionCode();
|
|
}
|
|
}
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
lstrcpy(szServiceDisplayName, lpDriverName);
|
|
}
|
|
|
|
if (hKeyDriver != NULL) {
|
|
RegCloseKey(hKeyDriver);
|
|
}
|
|
if (hKeyMachine != NULL && hKeyMachine != HKEY_LOCAL_MACHINE) {
|
|
RegCloseKey(hKeyMachine);
|
|
}
|
|
ErrorCode = ERROR_SUCCESS;
|
|
|
|
if (!BuildLanguageTables((LPWSTR)lpIniFile, &LangList)) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_LANGLIST_ERR), lpIniFile);
|
|
ErrorCode = GetLastError();
|
|
goto EndOfMain;
|
|
}
|
|
|
|
if (!LoadIncludeFile((LPWSTR)lpIniFile, &SymbolTable)) {
|
|
// open errors displayed in routine
|
|
ErrorCode = GetLastError();
|
|
goto EndOfMain;
|
|
}
|
|
|
|
if (!UpdateRegistry((LPWSTR) lpIniFile,
|
|
lpDriverName,
|
|
& LangList,
|
|
SymbolTable,
|
|
plObjectGuidTable,
|
|
& dwObjectGuidTableSize,
|
|
(LPDWORD) & dwIndexValues)) {
|
|
ErrorCode = GetLastError();
|
|
goto EndOfMain;
|
|
}
|
|
|
|
if (ComputerName[0] == 0) { // until remote is supported
|
|
LodctrSetSericeAsTrusted(
|
|
lpIniFile,
|
|
NULL,
|
|
lpDriverName);
|
|
}
|
|
|
|
// now it's time to load the MOF for WBEM access
|
|
if (!(dwFlags & LOADPERF_FLAGS_LOAD_REGISTRY_ONLY)) {
|
|
// the didn't say not to, so create if necessary and
|
|
// load the MOF into the CIMOM
|
|
|
|
// see if there's a mof file in the Ini file (if so, use that)
|
|
ErrorCode = GetMofFileFromIni (lpIniFile, MofFilename);
|
|
|
|
if (ErrorCode == ERROR_FILE_NOT_FOUND) {
|
|
WCHAR wszTempFilename[MAX_PATH];
|
|
MakeTempFileName (lpDriverName, wszTempFilename);
|
|
// otherwise we'll try to make one
|
|
ErrorCode = OpenCounterAndBuildMofFile (
|
|
lpDriverName, wszTempFilename,
|
|
plObjectGuidTable,
|
|
dwObjectGuidTableSize);
|
|
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
lstrcpyW (MofFilename, wszTempFilename);
|
|
} else {
|
|
// report unable to create mof file
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_NO_MOF_FILE_CREATED, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
2, (LPWSTR) lpDriverName, wszTempFilename, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_INSTALLPERFDLL,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ErrorCode,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(wszTempFilename),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
// now let's load it into the CIMOM
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
ErrorCode = LodctrCompileMofFile ( ComputerName, MofFilename );
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
// display error message
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_NO_MOF_FILE_LOADED, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
2, (LPWSTR) lpDriverName, MofFilename, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_INSTALLPERFDLL,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ErrorCode,
|
|
TRACE_WSTR(lpDriverName),
|
|
TRACE_WSTR(MofFilename),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
// toss the mof if they don't want it
|
|
if ((ErrorCode == ERROR_SUCCESS) &&
|
|
(dwFlags & LOADPERF_FLAGS_DELETE_MOF_ON_EXIT)) {
|
|
// display error message
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_CANT_DELETE_MOF, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
1, (LPWSTR) lpDriverName, NULL, NULL);
|
|
}
|
|
// reset the error code to success since all worked before the
|
|
// MOF operations.
|
|
ErrorCode = ERROR_SUCCESS;
|
|
}
|
|
// signal WMI with this change, ignore WMI return error.
|
|
SignalWmiWithNewData (WMI_LODCTR_EVENT);
|
|
} else {
|
|
if (lpIniFile == NULL) {
|
|
OUTPUT_MESSAGE (GetFormatResource(LC_NO_INIFILE), lpIniFile);
|
|
ErrorCode = ERROR_OPEN_FAILED;
|
|
} else {
|
|
//Incorrect Command Format
|
|
// display command line usage
|
|
if (!bQuietMode) {
|
|
DisplayCommandHelp(LC_FIRST_CMD_HELP, LC_LAST_CMD_HELP);
|
|
}
|
|
ErrorCode = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
EndOfMain:
|
|
if (ErrorCode != ERROR_SUCCESS) {
|
|
if (ErrorCode == ERROR_ALREADY_EXISTS) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_INFORMATION_TYPE, // error type
|
|
(DWORD) LDPRFMSG_ALREADY_EXIST, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
2, (LPWSTR) lpDriverName, (LPWSTR) szServiceDisplayName, NULL);
|
|
ErrorCode = ERROR_SUCCESS;
|
|
}
|
|
else if (lpDriverName != NULL) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_LOAD_FAILURE, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpDriverName, NULL, NULL);
|
|
}
|
|
else if (lpIniFile != NULL) {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_LOAD_FAILURE, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
1, (LPWSTR) lpIniFile, NULL, NULL);
|
|
}
|
|
else {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_ERROR_TYPE, // error type
|
|
(DWORD) LDPRFMSG_LOAD_FAILURE, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
0, NULL, NULL, NULL);
|
|
}
|
|
} else {
|
|
// log success message
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_INFORMATION_TYPE, // error type
|
|
(DWORD) LDPRFMSG_LOAD_SUCCESS, // event,
|
|
1, __LINE__, 0, 0, 0,
|
|
2, (LPWSTR) lpDriverName, (LPWSTR) szServiceDisplayName, NULL);
|
|
}
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_INSTALLPERFDLL,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ErrorCode,
|
|
TRACE_WSTR(lpDriverName),
|
|
NULL));
|
|
|
|
for (dwObjectIndex = 0; dwObjectIndex < dwObjectGuidTableSize; dwObjectIndex++) {
|
|
if (plObjectGuidTable[dwObjectIndex].GuidString != NULL) {
|
|
MemoryFree (plObjectGuidTable[dwObjectIndex].GuidString);
|
|
}
|
|
}
|
|
if (lpDriverName) MemoryFree (lpDriverName);
|
|
return (ErrorCode);
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
InstallPerfDllA (
|
|
IN LPCSTR szComputerName,
|
|
IN LPCSTR szIniFile,
|
|
IN ULONG_PTR dwFlags
|
|
)
|
|
{
|
|
LPWSTR lpWideComputerName = NULL;
|
|
LPWSTR lpWideFileName = NULL;
|
|
DWORD dwStrLen;
|
|
DWORD lReturn;
|
|
|
|
if (szIniFile != NULL) {
|
|
//length of string including terminator
|
|
dwStrLen = lstrlenA(szIniFile) + 1;
|
|
|
|
lpWideFileName = MemoryAllocate (dwStrLen * sizeof(WCHAR));
|
|
if (lpWideFileName != NULL) {
|
|
mbstowcs (lpWideFileName, szIniFile, dwStrLen);
|
|
lReturn = ERROR_SUCCESS;
|
|
} else {
|
|
lReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
lReturn = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (lReturn == ERROR_SUCCESS) {
|
|
if (szComputerName != NULL) {
|
|
dwStrLen = lstrlenA (szComputerName) + 1;
|
|
lpWideComputerName = (LPWSTR)MemoryAllocate (dwStrLen * sizeof(WCHAR));
|
|
if (lpWideComputerName != NULL) {
|
|
mbstowcs (lpWideComputerName, szComputerName, dwStrLen);
|
|
lReturn = ERROR_SUCCESS;
|
|
} else {
|
|
lReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
lpWideComputerName = NULL;
|
|
lReturn = ERROR_SUCCESS;
|
|
}
|
|
|
|
}
|
|
|
|
if (lReturn == ERROR_SUCCESS) {
|
|
lReturn = InstallPerfDllW (
|
|
lpWideComputerName,
|
|
lpWideFileName,
|
|
dwFlags);
|
|
MemoryFree (lpWideFileName);
|
|
MemoryFree (lpWideComputerName);
|
|
}
|
|
|
|
return lReturn;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
LoadPerfCounterTextStringsW (
|
|
IN LPWSTR lpCommandLine,
|
|
IN BOOL bQuietModeArg
|
|
)
|
|
/*++
|
|
|
|
LoadPerfCounterTexStringsW
|
|
|
|
loads the perf counter strings into the registry and updates
|
|
the perf counter text registry values
|
|
|
|
Arguments
|
|
|
|
command line string in the following format:
|
|
|
|
"/?" displays the usage text
|
|
"file.ini" loads the perf strings found in file.ini
|
|
"\\machine file.ini" loads the perf strings found onto machine
|
|
|
|
|
|
ReturnValue
|
|
|
|
0 (ERROR_SUCCESS) if command was processed
|
|
Non-Zero if command error was detected.
|
|
|
|
--*/
|
|
{
|
|
LPWSTR lpIniFile;
|
|
|
|
DWORD ErrorCode = ERROR_SUCCESS;
|
|
ULONG_PTR dwFlags = 0;
|
|
|
|
WinPerfStartTrace(NULL);
|
|
|
|
dwFlags |= (bQuietModeArg ? 0 : LOADPERF_FLAGS_DISPLAY_USER_MSGS);
|
|
|
|
lpIniFile = MemoryAllocate (MAX_PATH * sizeof (TCHAR));
|
|
|
|
if (!lpIniFile) {
|
|
return (ERROR_OUTOFMEMORY);
|
|
}
|
|
*lpIniFile = 0;
|
|
|
|
// init last error value
|
|
SetLastError (ERROR_SUCCESS);
|
|
|
|
// read command line to determine what to do
|
|
if (GetFileFromCommandLine (lpCommandLine, &lpIniFile, &dwFlags)) {
|
|
dwFlags |= LOADPERF_FLAGS_LOAD_REGISTRY_ONLY; // don't do mof's even if they want
|
|
// call installation function
|
|
ErrorCode = InstallPerfDllW (ComputerName, lpIniFile, dwFlags);
|
|
} else {
|
|
//Incorrect Command Format
|
|
// display command line usage
|
|
if (!bQuietModeArg) {
|
|
DisplayCommandHelp(LC_FIRST_CMD_HELP, LC_LAST_CMD_HELP);
|
|
}
|
|
ErrorCode = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (lpIniFile) MemoryFree (lpIniFile);
|
|
|
|
return (ErrorCode);
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
LoadPerfCounterTextStringsA (
|
|
IN LPSTR lpAnsiCommandLine,
|
|
IN BOOL bQuietModeArg
|
|
)
|
|
{
|
|
LPWSTR lpWideCommandLine;
|
|
DWORD dwStrLen;
|
|
DWORD lReturn;
|
|
|
|
if (lpAnsiCommandLine != NULL) {
|
|
//length of string including terminator
|
|
dwStrLen = lstrlenA(lpAnsiCommandLine) + 1;
|
|
|
|
lpWideCommandLine = MemoryAllocate (dwStrLen * sizeof(WCHAR));
|
|
if (lpWideCommandLine != NULL) {
|
|
mbstowcs (lpWideCommandLine, lpAnsiCommandLine, dwStrLen);
|
|
lReturn = LoadPerfCounterTextStringsW (lpWideCommandLine,
|
|
bQuietModeArg );
|
|
MemoryFree (lpWideCommandLine);
|
|
} else {
|
|
lReturn = GetLastError();
|
|
}
|
|
} else {
|
|
lReturn = ERROR_INVALID_PARAMETER;
|
|
}
|
|
return lReturn;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
LoadMofFromInstalledServiceW (
|
|
IN LPCWSTR szServiceName, // service to create mof for
|
|
IN LPCWSTR szMofFilenameArg, // name of file to create
|
|
IN ULONG_PTR dwFlags // flags
|
|
)
|
|
{
|
|
DWORD ErrorCode;
|
|
WCHAR wszTempFilename[MAX_PATH];
|
|
|
|
WinPerfStartTrace(NULL);
|
|
|
|
if (szServiceName == NULL) {
|
|
ErrorCode = ERROR_INVALID_PARAMETER;
|
|
} else {
|
|
ZeroMemory(wszTempFilename, sizeof(WCHAR) * MAX_PATH);
|
|
if (szMofFilenameArg == NULL) {
|
|
MakeTempFileName (szServiceName, wszTempFilename);
|
|
} else {
|
|
lstrcpyW (wszTempFilename, szMofFilenameArg);
|
|
}
|
|
|
|
// otherwise we'll try to make one
|
|
ErrorCode = OpenCounterAndBuildMofFile (
|
|
szServiceName, wszTempFilename,
|
|
NULL, 0L);
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADMOFFROMINSTALLEDSERVICE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ErrorCode,
|
|
TRACE_WSTR(szServiceName),
|
|
TRACE_WSTR(wszTempFilename),
|
|
NULL));
|
|
|
|
// now let's load it into the CIMOM
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
ErrorCode = SignalWmiWithNewData (WMI_LODCTR_EVENT);
|
|
} else {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_NO_MOF_FILE_CREATED, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
1, (LPWSTR) szServiceName, NULL, NULL);
|
|
}
|
|
|
|
// if everything is going well and the caller
|
|
// wants to delete the file created to contain the MOF
|
|
// then delete it
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
if ((dwFlags & LOADPERF_FLAGS_DELETE_MOF_ON_EXIT) && (szMofFilenameArg == NULL)) {
|
|
if (!DeleteFile(wszTempFilename)) {
|
|
ErrorCode = GetLastError();
|
|
}
|
|
}
|
|
} else {
|
|
ReportLoadPerfEvent(
|
|
EVENTLOG_WARNING_TYPE, // error type
|
|
(DWORD) LDPRFMSG_NO_MOF_FILE_LOADED, // event,
|
|
2, ErrorCode, __LINE__, 0, 0,
|
|
1, (LPWSTR) szServiceName, NULL, NULL);
|
|
TRACE((WINPERF_DBG_TRACE_WARNING),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_LOADMOFFROMINSTALLEDSERVICE,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ErrorCode,
|
|
TRACE_WSTR(szServiceName),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
return (ErrorCode);
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
LoadMofFromInstalledServiceA (
|
|
IN LPCSTR szServiceName, // service to create mof for
|
|
IN LPCSTR szMofFilenameArg, // name of file to create
|
|
IN ULONG_PTR dwFlags // delete mof on exit
|
|
)
|
|
{
|
|
DWORD ErrorCode = ERROR_SUCCESS;
|
|
LPWSTR wszServiceName;
|
|
DWORD dwServiceNameLen;
|
|
LPWSTR wszMofFilename;
|
|
DWORD dwMofFilenameLen;
|
|
|
|
if (szServiceName == NULL) {
|
|
ErrorCode = ERROR_INVALID_PARAMETER;
|
|
} else {
|
|
dwServiceNameLen = lstrlenA(szServiceName) + 1;
|
|
wszServiceName = MemoryAllocate (
|
|
dwServiceNameLen * sizeof(WCHAR));
|
|
if (wszServiceName == NULL) {
|
|
ErrorCode = ERROR_OUTOFMEMORY;
|
|
} else {
|
|
mbstowcs (wszServiceName, szServiceName, dwServiceNameLen);
|
|
if (szMofFilenameArg != NULL) {
|
|
dwMofFilenameLen = lstrlenA(szMofFilenameArg) + 1;
|
|
wszMofFilename = MemoryAllocate (dwMofFilenameLen);
|
|
if (wszMofFilename != NULL) {
|
|
mbstowcs (wszMofFilename, szMofFilenameArg, dwMofFilenameLen);
|
|
} else {
|
|
ErrorCode = ERROR_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
wszMofFilename = NULL;
|
|
}
|
|
if (ErrorCode == ERROR_SUCCESS) {
|
|
ErrorCode = LoadMofFromInstalledServiceW (
|
|
wszServiceName,
|
|
wszMofFilename,
|
|
dwFlags);
|
|
}
|
|
if (wszMofFilename != NULL) MemoryFree (wszMofFilename);
|
|
MemoryFree (wszServiceName);
|
|
}
|
|
}
|
|
return ErrorCode;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
UpdatePerfNameFilesX (
|
|
IN LPCWSTR szNewCtrFilePath, // data file with new base counter strings
|
|
IN LPCWSTR szNewHlpFilePath, // data file with new base counter strings
|
|
IN LPWSTR szLanguageID, // Lang ID to update
|
|
IN ULONG_PTR dwFlags // flags
|
|
)
|
|
{
|
|
DWORD dwReturn = ERROR_SUCCESS;
|
|
|
|
LPWSTR szCtrNameIn = NULL;
|
|
LPWSTR szHlpNameIn = NULL;
|
|
LPWSTR szNewCtrStrings = NULL;
|
|
LPWSTR szNewHlpStrings = NULL;
|
|
LPWSTR szNewCtrMSZ = NULL;
|
|
LPWSTR szNewHlpMSZ = NULL;
|
|
WCHAR szSystemPath[MAX_PATH];
|
|
DWORD dwLength;
|
|
LPWSTR *pszNewNameTable = NULL;
|
|
LPWSTR *pszOldNameTable = NULL;
|
|
LPWSTR lpThisName;
|
|
LPWSTR szThisCtrString = NULL;
|
|
LPWSTR szThisHlpString = NULL;
|
|
WCHAR szLangSection[MAX_PATH];
|
|
DWORD dwOldLastEntry = 0;
|
|
DWORD dwNewLastEntry = 0;
|
|
DWORD dwStringSize;
|
|
DWORD dwHlpFileSize = 0, dwCtrFileSize = 0 ;
|
|
DWORD dwThisCounter;
|
|
DWORD dwSize;
|
|
DWORD dwLastBaseValue = 0;
|
|
DWORD dwType;
|
|
DWORD dwIndex;
|
|
HANDLE hCtrFileIn = INVALID_HANDLE_VALUE;
|
|
HANDLE hCtrFileMap = NULL;
|
|
HANDLE hHlpFileIn = INVALID_HANDLE_VALUE;
|
|
HANDLE hHlpFileMap = NULL;
|
|
HKEY hKeyPerflib;
|
|
|
|
WinPerfStartTrace(NULL);
|
|
|
|
if (szNewCtrFilePath == NULL) dwReturn = ERROR_INVALID_PARAMETER;
|
|
if ((szNewHlpFilePath == NULL) && !(dwFlags & LODCTR_UPNF_RESTORE)) dwReturn = ERROR_INVALID_PARAMETER;
|
|
if (szLanguageID == NULL) dwReturn = ERROR_INVALID_PARAMETER;
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(szNewCtrFilePath),
|
|
TRACE_WSTR(szLanguageID),
|
|
NULL));
|
|
}
|
|
|
|
if ((dwReturn == ERROR_SUCCESS) && !(dwFlags & LODCTR_UPNF_RESTORE)) {
|
|
// save the original files, unless it's a restoration
|
|
MakeBackupCopyOfLanguageFiles (szLanguageID);
|
|
dwLength = ExpandEnvironmentStringsW ((LPCWSTR)L"%windir%\\system32",
|
|
(LPWSTR)szSystemPath, (sizeof(szSystemPath) / sizeof(szSystemPath[0])));
|
|
} else {
|
|
dwLength = 0;
|
|
SetLastError (dwReturn);
|
|
}
|
|
|
|
if (dwLength > 0) {
|
|
// create input filenames
|
|
szCtrNameIn = MemoryAllocate (MAX_PATH * 2 * sizeof (WCHAR));
|
|
szHlpNameIn = MemoryAllocate (MAX_PATH * 2 * sizeof (WCHAR));
|
|
|
|
if ((szCtrNameIn != NULL) && (szHlpNameIn != NULL)) {
|
|
ExpandEnvironmentStrings (szNewCtrFilePath, szCtrNameIn, (MAX_PATH * 2));
|
|
ExpandEnvironmentStrings (szNewHlpFilePath, szHlpNameIn, (MAX_PATH * 2));
|
|
} else {
|
|
dwReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// open and map new files
|
|
hCtrFileIn = CreateFile (
|
|
szCtrNameIn, GENERIC_READ,
|
|
FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hCtrFileIn != INVALID_HANDLE_VALUE) {
|
|
// map file
|
|
dwCtrFileSize = GetFileSize(hCtrFileIn, NULL);
|
|
if (dwCtrFileSize == 0xFFFFFFFF){
|
|
dwReturn =GetLastError();
|
|
}
|
|
|
|
hCtrFileMap = CreateFileMapping (
|
|
hCtrFileIn, NULL, PAGE_READONLY, 0, 0, NULL);
|
|
if (hCtrFileMap != NULL) {
|
|
szNewCtrStrings = (LPWSTR)MapViewOfFileEx (
|
|
hCtrFileMap, FILE_MAP_READ, 0, 0, 0, NULL);
|
|
if (szNewCtrStrings == NULL) {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// open and map new files
|
|
hHlpFileIn = CreateFile (
|
|
szHlpNameIn, GENERIC_READ,
|
|
FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hHlpFileIn != INVALID_HANDLE_VALUE) {
|
|
// map file
|
|
dwHlpFileSize = GetFileSize (hHlpFileIn, NULL);
|
|
if (dwHlpFileSize == 0xFFFFFFFF){
|
|
dwReturn =GetLastError();
|
|
}
|
|
hHlpFileMap = CreateFileMapping (
|
|
hHlpFileIn, NULL, PAGE_READONLY, 0, 0, NULL);
|
|
if (hHlpFileMap != NULL) {
|
|
szNewHlpStrings = (LPWSTR)MapViewOfFileEx (
|
|
hHlpFileMap, FILE_MAP_READ, 0, 0, 0, NULL);
|
|
if (szNewHlpStrings == NULL) {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else if (dwFlags & LODCTR_UPNF_RESTORE) {
|
|
szCtrNameIn = MemoryAllocate (MAX_PATH * 2 * sizeof (WCHAR));
|
|
|
|
if (szCtrNameIn != NULL) {
|
|
dwLength = ExpandEnvironmentStringsW (szNewCtrFilePath,
|
|
szCtrNameIn, (sizeof(szSystemPath) / sizeof(szSystemPath[0])));
|
|
|
|
dwNewLastEntry = GetPrivateProfileIntW (
|
|
(LPCWSTR)L"Perflib",
|
|
(LPCWSTR)L"Last Help",
|
|
-1,
|
|
szCtrNameIn);
|
|
if (dwNewLastEntry != (DWORD)-1) {
|
|
// get the input file size
|
|
hCtrFileIn = CreateFile (
|
|
szCtrNameIn, GENERIC_READ,
|
|
FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hCtrFileIn != INVALID_HANDLE_VALUE) {
|
|
// map file
|
|
dwCtrFileSize = GetFileSize (hCtrFileIn, NULL);
|
|
} else {
|
|
dwCtrFileSize = 64 * 1024; // assign 64k if unable to read it
|
|
}
|
|
// load new values from ini file
|
|
szNewCtrStrings = (LPWSTR)MemoryAllocate (dwCtrFileSize * sizeof(WCHAR));
|
|
if (szNewCtrStrings) {
|
|
lstrcpyW (szLangSection, (LPCWSTR)L"Perfstrings_");
|
|
lstrcatW (szLangSection, szLanguageID);
|
|
dwSize = GetPrivateProfileSectionW (
|
|
szLangSection,
|
|
szNewCtrStrings,
|
|
dwCtrFileSize,
|
|
szCtrNameIn);
|
|
if (dwSize == 0) {
|
|
lstrcpyW (szLangSection, (LPCWSTR) L"Perfstrings_009");
|
|
dwSize = GetPrivateProfileSectionW(
|
|
szLangSection,
|
|
szNewCtrStrings,
|
|
dwCtrFileSize,
|
|
szCtrNameIn);
|
|
}
|
|
if (dwSize == 0) {
|
|
dwReturn = ERROR_FILE_INVALID;
|
|
} else {
|
|
// set file sizes
|
|
dwHlpFileSize = 0;
|
|
dwCtrFileSize = (dwSize+2) * sizeof(WCHAR);
|
|
}
|
|
} else {
|
|
dwReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
// unable to open input file or file is invalid
|
|
dwReturn = ERROR_FILE_INVALID;
|
|
}
|
|
} else {
|
|
dwReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if ((dwReturn == ERROR_SUCCESS) && (!(dwFlags & LODCTR_UPNF_RESTORE))) {
|
|
// build name table of current strings
|
|
pszOldNameTable = BuildNameTable (
|
|
HKEY_LOCAL_MACHINE,
|
|
szLanguageID,
|
|
&dwOldLastEntry);
|
|
if (pszOldNameTable == NULL) {
|
|
dwReturn = GetLastError();
|
|
}
|
|
dwNewLastEntry = (dwOldLastEntry == 0) ? (PERFLIB_BASE_INDEX)
|
|
: (dwOldLastEntry);
|
|
}
|
|
else if (dwFlags & LODCTR_UPNF_RESTORE) {
|
|
dwOldLastEntry = dwNewLastEntry;
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// build name table of new strings
|
|
pszNewNameTable = (LPWSTR *)MemoryAllocate(
|
|
(dwNewLastEntry + 2) * sizeof(LPWSTR)); // allow for index offset
|
|
if (pszNewNameTable != NULL) {
|
|
for (lpThisName = szNewCtrStrings;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
if (dwThisCounter == 0) {
|
|
continue; // bad entry, try next
|
|
}
|
|
|
|
// point to corresponding counter name
|
|
|
|
if (dwFlags & LODCTR_UPNF_RESTORE) {
|
|
// point to string that follows the "=" char
|
|
lpThisName = wcschr (lpThisName, L'=');
|
|
if (lpThisName != NULL) {
|
|
lpThisName++;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else {
|
|
// string is next in MSZ
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
}
|
|
|
|
// and load array element;
|
|
|
|
pszNewNameTable[dwThisCounter] = lpThisName;
|
|
}
|
|
|
|
if (!(dwFlags & LODCTR_UPNF_RESTORE)) {
|
|
for (lpThisName = szNewHlpStrings;
|
|
*lpThisName;
|
|
lpThisName += (lstrlen(lpThisName)+1) ) {
|
|
|
|
// first string should be an integer (in decimal unicode digits)
|
|
|
|
dwThisCounter = wcstoul (lpThisName, NULL, 10);
|
|
if (dwThisCounter == 0) {
|
|
continue; // bad entry, try next
|
|
}
|
|
|
|
// point to corresponding counter name
|
|
|
|
lpThisName += (lstrlen(lpThisName)+1);
|
|
|
|
// and load array element;
|
|
|
|
pszNewNameTable[dwThisCounter] = lpThisName;
|
|
}
|
|
}
|
|
|
|
// allocate string buffers for the resulting string
|
|
// we want to make sure there's plenty of room so we'll make it
|
|
// the size of the input file + the current buffer
|
|
|
|
dwStringSize = dwHlpFileSize;
|
|
dwStringSize += dwCtrFileSize;
|
|
if (pszOldNameTable != NULL) {
|
|
dwStringSize += MemorySize(pszOldNameTable);
|
|
}
|
|
|
|
szNewCtrMSZ = MemoryAllocate (dwStringSize);
|
|
szNewHlpMSZ = MemoryAllocate (dwStringSize);
|
|
|
|
if ((szNewCtrMSZ == NULL) || (szNewHlpMSZ == NULL)) {
|
|
dwReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
dwReturn = ERROR_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// write new strings into registry
|
|
__try {
|
|
dwReturn = RegOpenKeyEx (
|
|
HKEY_LOCAL_MACHINE,
|
|
NamesKey,
|
|
RESERVED,
|
|
KEY_READ,
|
|
& hKeyPerflib);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
dwReturn = GetExceptionCode();
|
|
}
|
|
dwSize = sizeof (dwLastBaseValue);
|
|
dwLastBaseValue = 0;
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
__try {
|
|
dwReturn = RegQueryValueEx (
|
|
hKeyPerflib,
|
|
szBaseIndex,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPBYTE) & dwLastBaseValue,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
dwReturn = GetExceptionCode();
|
|
}
|
|
if (dwLastBaseValue == 0) {
|
|
dwReturn = ERROR_BADDB;
|
|
}
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
dwReturn,
|
|
TRACE_WSTR(szBaseIndex),
|
|
TRACE_DWORD(dwLastBaseValue),
|
|
NULL));
|
|
|
|
RegCloseKey (hKeyPerflib);
|
|
}
|
|
}
|
|
else {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
dwReturn,
|
|
TRACE_WSTR(NamesKey),
|
|
NULL));
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
DWORD dwLoopLimit;
|
|
// the strings should be mapped by now
|
|
// pszNewNameTable contains the new strings from the
|
|
// source path and pszOldNameTable contains the strings
|
|
// from the original system. The merge will consist of
|
|
// taking all base values from the new table and the
|
|
// extended values from the old table.
|
|
dwIndex =1;
|
|
szThisCtrString = szNewCtrMSZ;
|
|
szThisHlpString = szNewHlpMSZ;
|
|
|
|
// index 1 is a special case and belongs in the counter string
|
|
// after that even numbers (starting w/ #2) go into the counter string
|
|
// and odd numbers (starting w/ #3) go into the help string
|
|
|
|
assert (pszNewNameTable[dwIndex] != NULL);
|
|
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%d", dwIndex) + 1;
|
|
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%s", pszNewNameTable[dwIndex]) + 1;
|
|
|
|
dwIndex++;
|
|
assert (dwIndex == 2);
|
|
|
|
if (dwFlags & LODCTR_UPNF_RESTORE) {
|
|
// restore ALL strings from the input file only if this
|
|
// is a restoration
|
|
dwLoopLimit = dwOldLastEntry;
|
|
} else {
|
|
// only update the system counters from the input file
|
|
dwLoopLimit = dwLastBaseValue;
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
0,
|
|
ERROR_SUCCESS,
|
|
TRACE_DWORD(dwOldLastEntry),
|
|
TRACE_DWORD(dwLastBaseValue),
|
|
NULL));
|
|
|
|
for (/*dwIndex from above*/; dwIndex <= dwLoopLimit; dwIndex++) {
|
|
if (pszNewNameTable[dwIndex] != NULL) {
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(pszNewNameTable[dwIndex]),
|
|
TRACE_DWORD(dwIndex),
|
|
NULL));
|
|
if (dwIndex & 0x01) {
|
|
// then it's a help string
|
|
szThisHlpString += swprintf (szThisHlpString,
|
|
(LPCWSTR)L"%d", dwIndex) + 1;
|
|
|
|
szThisHlpString += swprintf (szThisHlpString,
|
|
(LPCWSTR)L"%s", pszNewNameTable[dwIndex]) + 1;
|
|
} else {
|
|
// it's a counter string
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%d", dwIndex) + 1;
|
|
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%s", pszNewNameTable[dwIndex]) + 1;
|
|
}
|
|
} // else just skip it
|
|
}
|
|
for (/*dwIndex from last run */;dwIndex <= dwOldLastEntry; dwIndex++) {
|
|
if (pszOldNameTable[dwIndex] != NULL) {
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
ERROR_SUCCESS,
|
|
TRACE_WSTR(pszOldNameTable[dwIndex]),
|
|
TRACE_DWORD(dwIndex),
|
|
NULL));
|
|
if (dwIndex & 0x01) {
|
|
// then it's a help string
|
|
szThisHlpString += swprintf (szThisHlpString,
|
|
(LPCWSTR)L"%d", dwIndex) + 1;
|
|
|
|
szThisHlpString += swprintf (szThisHlpString,
|
|
(LPCWSTR)L"%s", pszOldNameTable[dwIndex]) + 1;
|
|
} else {
|
|
// it's a counter string
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%d", dwIndex) + 1;
|
|
|
|
szThisCtrString += swprintf (szThisCtrString,
|
|
(LPCWSTR)L"%s", pszOldNameTable[dwIndex]) + 1;
|
|
}
|
|
} // else just skip it
|
|
}
|
|
// terminate the MSZ
|
|
*szThisCtrString++ = 0;
|
|
*szThisHlpString++ = 0;
|
|
}
|
|
|
|
// close mapped memory sections:
|
|
if (szNewCtrStrings != NULL) UnmapViewOfFile(szNewCtrStrings);
|
|
if (hCtrFileMap != NULL) CloseHandle(hCtrFileMap);
|
|
if (hCtrFileIn != NULL) CloseHandle(hCtrFileIn);
|
|
if (szNewHlpStrings != NULL) UnmapViewOfFile(szNewHlpStrings);
|
|
if (hHlpFileMap != NULL) CloseHandle(hHlpFileMap);
|
|
if (hHlpFileIn != NULL) CloseHandle(hHlpFileIn);
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// write new values to registry
|
|
LONG lStatus;
|
|
WCHAR AddCounterNameBuffer[20];
|
|
WCHAR AddHelpNameBuffer[20];
|
|
|
|
lstrcpyW(AddCounterNameBuffer, AddCounterNameStr);
|
|
lstrcatW(AddCounterNameBuffer, szLanguageID);
|
|
lstrcpyW(AddHelpNameBuffer, AddHelpNameStr);
|
|
lstrcatW(AddHelpNameBuffer, szLanguageID);
|
|
|
|
// because these are perf counter strings, RegQueryValueEx
|
|
// is used instead of RegSetValueEx as one might expect.
|
|
|
|
dwSize = (DWORD)((DWORD_PTR)szThisCtrString - (DWORD_PTR)szNewCtrMSZ);
|
|
__try {
|
|
lStatus = RegQueryValueExW (
|
|
HKEY_PERFORMANCE_DATA,
|
|
AddCounterNameBuffer,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPVOID) szNewCtrMSZ,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
dwReturn = (DWORD)lStatus;
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(AddCounterNameBuffer),
|
|
TRACE_DWORD(dwSize),
|
|
NULL));
|
|
}
|
|
|
|
dwSize = (DWORD)((DWORD_PTR)szThisHlpString - (DWORD_PTR)szNewHlpMSZ);
|
|
__try {
|
|
lStatus = RegQueryValueExW (
|
|
HKEY_PERFORMANCE_DATA,
|
|
AddHelpNameBuffer,
|
|
RESERVED,
|
|
& dwType,
|
|
(LPVOID) szNewHlpMSZ,
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
lStatus = GetExceptionCode();
|
|
}
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
dwReturn = (DWORD)lStatus;
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_UPDATEPERFNAMEFILES,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1),
|
|
lStatus,
|
|
TRACE_WSTR(AddHelpNameBuffer),
|
|
TRACE_DWORD(dwSize),
|
|
NULL));
|
|
}
|
|
}
|
|
|
|
if (szCtrNameIn != NULL) MemoryFree (szCtrNameIn);
|
|
if (szHlpNameIn != NULL) MemoryFree (szHlpNameIn);
|
|
if (pszNewNameTable != NULL) MemoryFree (pszNewNameTable);
|
|
if (pszOldNameTable != NULL) MemoryFree (pszOldNameTable);
|
|
if (szNewCtrMSZ != NULL) MemoryFree (szNewCtrMSZ);
|
|
if (szNewHlpMSZ != NULL) MemoryFree (szNewHlpMSZ);
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
// exported version of the above function
|
|
LOADPERF_FUNCTION
|
|
UpdatePerfNameFilesW (
|
|
IN LPCWSTR szNewCtrFilePath, // data file with new base counter strings
|
|
IN LPCWSTR szNewHlpFilePath, // data file with new base counter strings
|
|
IN LPWSTR szLanguageID, // Lang ID to update
|
|
IN ULONG_PTR dwFlags // flags
|
|
)
|
|
{
|
|
volatile DWORD dwStatus;
|
|
|
|
dwStatus = UpdatePerfNameFilesX (
|
|
szNewCtrFilePath, // data file with new base counter strings
|
|
szNewHlpFilePath, // data file with new base counter strings
|
|
szLanguageID, // Lang ID to update
|
|
dwFlags); // flags
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
UpdatePerfNameFilesA (
|
|
IN LPCSTR szNewCtrFilePath, // data file with new base counter strings
|
|
IN LPCSTR szNewHlpFilePath, // data file with new base counter strings
|
|
IN LPSTR szLanguageID, // Lang ID to update
|
|
IN ULONG_PTR dwFlags // flags
|
|
)
|
|
{
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
LPWSTR wszNewCtrFilePath = NULL;
|
|
LPWSTR wszNewHlpFilePath = NULL;
|
|
LPWSTR wszLanguageID = NULL;
|
|
DWORD dwLength;
|
|
|
|
if (szNewCtrFilePath != NULL) {
|
|
dwLength = lstrlenA (szNewCtrFilePath);
|
|
dwLength += 1; //add term null
|
|
wszNewCtrFilePath = MemoryAllocate (dwLength * sizeof(WCHAR));
|
|
if (wszNewCtrFilePath != NULL) {
|
|
mbstowcs (wszNewCtrFilePath, szNewCtrFilePath, dwLength);
|
|
}
|
|
} else {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (szNewHlpFilePath != NULL) {
|
|
dwLength = lstrlenA (szNewHlpFilePath);
|
|
dwLength += 1; //add term null
|
|
wszNewHlpFilePath = MemoryAllocate (dwLength * sizeof(WCHAR));
|
|
if (wszNewHlpFilePath != NULL) {
|
|
mbstowcs (wszNewHlpFilePath, szNewHlpFilePath, dwLength);
|
|
}
|
|
} else {
|
|
// this parameter can only be NULL if this flag bit is set.
|
|
if (!(dwFlags & LODCTR_UPNF_RESTORE)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
} else {
|
|
wszNewHlpFilePath = NULL;
|
|
}
|
|
}
|
|
|
|
if (szLanguageID != NULL) {
|
|
dwLength = lstrlenA (szLanguageID);
|
|
dwLength += 1; //add term null
|
|
wszLanguageID= MemoryAllocate (dwLength * sizeof(WCHAR));
|
|
if (wszLanguageID != NULL) {
|
|
mbstowcs (wszLanguageID, szLanguageID, dwLength);
|
|
}
|
|
} else {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (dwError == ERROR_SUCCESS) {
|
|
dwError = UpdatePerfNameFilesX (
|
|
wszNewCtrFilePath,
|
|
wszNewHlpFilePath,
|
|
wszLanguageID,
|
|
dwFlags);
|
|
}
|
|
|
|
if (wszNewCtrFilePath != NULL) MemoryFree (wszNewCtrFilePath);
|
|
if (wszNewHlpFilePath != NULL) MemoryFree (wszNewHlpFilePath);
|
|
if (wszLanguageID != NULL) MemoryFree (wszLanguageID);
|
|
|
|
return dwError;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
SetServiceAsTrustedW (
|
|
LPCWSTR szMachineName, // reserved, MBZ
|
|
LPCWSTR szServiceName
|
|
)
|
|
{
|
|
HKEY hKeyService_Perf;
|
|
DWORD dwReturn;
|
|
WCHAR szPerfKeyString[MAX_PATH * 2];
|
|
HKEY hKeyLM = HKEY_LOCAL_MACHINE; // until remote machine access is supported
|
|
WCHAR szLibName[MAX_PATH * 2];
|
|
WCHAR szExpLibName[MAX_PATH * 2];
|
|
WCHAR szFullPathName[MAX_PATH * 2];
|
|
DWORD dwSize, dwType;
|
|
HANDLE hFile;
|
|
DllValidationData dvdLibrary;
|
|
LARGE_INTEGER liSize;
|
|
BOOL bStatus;
|
|
|
|
WinPerfStartTrace(NULL);
|
|
|
|
if ((szMachineName != NULL) || (szServiceName == NULL)) {
|
|
// reserved for future use
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// build path to performance subkey
|
|
lstrcpyW (szPerfKeyString, DriverPathRoot); // SYSTEM\CurrentControlSet\Services
|
|
lstrcatW (szPerfKeyString, Slash);
|
|
lstrcatW (szPerfKeyString, szServiceName);
|
|
lstrcatW (szPerfKeyString, Slash);
|
|
lstrcatW (szPerfKeyString, Performance);
|
|
|
|
// open performance key under the service key
|
|
__try {
|
|
dwReturn = RegOpenKeyExW (
|
|
hKeyLM,
|
|
szPerfKeyString,
|
|
0L,
|
|
KEY_READ | KEY_WRITE,
|
|
& hKeyService_Perf);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
dwReturn = GetExceptionCode();
|
|
}
|
|
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// get library name
|
|
dwType = 0;
|
|
dwSize = sizeof(szLibName) / sizeof (szLibName[0]);
|
|
__try {
|
|
dwReturn = RegQueryValueExW (
|
|
hKeyService_Perf,
|
|
cszLibrary,
|
|
NULL,
|
|
& dwType,
|
|
(LPBYTE) & szLibName[0],
|
|
& dwSize);
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
dwReturn = GetExceptionCode();
|
|
}
|
|
if (dwReturn == ERROR_SUCCESS) {
|
|
// expand path name if necessary
|
|
if (dwType == REG_EXPAND_SZ) {
|
|
dwSize = ExpandEnvironmentStringsW (
|
|
szLibName,
|
|
szExpLibName,
|
|
sizeof(szExpLibName) / sizeof (szExpLibName[0]));
|
|
} else {
|
|
lstrcpyW (szExpLibName, szLibName);
|
|
// dwSize is same as returned from Fn Call.
|
|
}
|
|
|
|
if (dwSize != 0) {
|
|
// find DLL file
|
|
dwSize = SearchPathW (
|
|
NULL,
|
|
szExpLibName,
|
|
NULL,
|
|
sizeof(szFullPathName) / sizeof (szFullPathName[0]),
|
|
szFullPathName,
|
|
NULL);
|
|
|
|
if (dwSize > 0) {
|
|
hFile = CreateFileW (
|
|
szFullPathName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE) {
|
|
// read file date/time & size
|
|
bStatus = GetFileTime (
|
|
hFile,
|
|
&dvdLibrary.CreationDate,
|
|
NULL,
|
|
NULL);
|
|
if (bStatus) {
|
|
liSize.LowPart = GetFileSize (
|
|
hFile,
|
|
(DWORD *)&liSize.HighPart);
|
|
dvdLibrary.FileSize = liSize.QuadPart;
|
|
// set registry value
|
|
__try {
|
|
dwReturn = RegSetValueExW (
|
|
hKeyService_Perf,
|
|
szLibraryValidationCode,
|
|
0L,
|
|
REG_BINARY,
|
|
(LPBYTE) & dvdLibrary,
|
|
sizeof(dvdLibrary));
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
dwReturn = GetExceptionCode();
|
|
}
|
|
|
|
TRACE((WINPERF_DBG_TRACE_INFO),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SETSERVICEASTRUSTED,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2) | ARG_DEF(ARG_TYPE_WSTR, 3),
|
|
dwReturn,
|
|
TRACE_WSTR(szServiceName),
|
|
TRACE_WSTR(szExpLibName),
|
|
TRACE_WSTR(szLibraryValidationCode),
|
|
NULL));
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
CloseHandle (hFile);
|
|
} else {
|
|
dwReturn = GetLastError();
|
|
}
|
|
} else {
|
|
dwReturn = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
} else {
|
|
// unable to expand environment strings
|
|
dwReturn = GetLastError();
|
|
}
|
|
}
|
|
else {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SETSERVICEASTRUSTED,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
dwReturn,
|
|
TRACE_WSTR(szServiceName),
|
|
TRACE_WSTR(cszLibrary),
|
|
NULL));
|
|
}
|
|
// close key
|
|
RegCloseKey (hKeyService_Perf);
|
|
}
|
|
else {
|
|
TRACE((WINPERF_DBG_TRACE_ERROR),
|
|
(& LoadPerfGuid,
|
|
__LINE__,
|
|
LOADPERF_SETSERVICEASTRUSTED,
|
|
ARG_DEF(ARG_TYPE_WSTR, 1) | ARG_DEF(ARG_TYPE_WSTR, 2),
|
|
dwReturn,
|
|
TRACE_WSTR(szServiceName),
|
|
TRACE_WSTR(Performance),
|
|
NULL));
|
|
}
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
LOADPERF_FUNCTION
|
|
SetServiceAsTrustedA (
|
|
LPCSTR szMachineName, // reserved, MBZ
|
|
LPCSTR szServiceName
|
|
)
|
|
{
|
|
LPWSTR lpWideServiceName;
|
|
DWORD dwStrLen;
|
|
DWORD lReturn;
|
|
|
|
if ((szMachineName != NULL) || (szServiceName == NULL)) {
|
|
// reserved for future use
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (szServiceName != NULL) {
|
|
//length of string including terminator
|
|
dwStrLen = lstrlenA(szServiceName) + 1;
|
|
lpWideServiceName = MemoryAllocate (dwStrLen * sizeof(WCHAR));
|
|
if (lpWideServiceName != NULL) {
|
|
mbstowcs (lpWideServiceName, szServiceName, dwStrLen);
|
|
lReturn = SetServiceAsTrustedW (NULL, lpWideServiceName);
|
|
MemoryFree (lpWideServiceName);
|
|
} else {
|
|
lReturn = GetLastError();
|
|
}
|
|
} else {
|
|
lReturn = ERROR_INVALID_PARAMETER;
|
|
}
|
|
return lReturn;
|
|
}
|
|
|
|
int __cdecl
|
|
My_vfwprintf(
|
|
FILE *str,
|
|
const wchar_t *format,
|
|
va_list argptr
|
|
)
|
|
{
|
|
HANDLE hOut;
|
|
|
|
if (str == stderr) {
|
|
hOut = GetStdHandle(STD_ERROR_HANDLE);
|
|
}
|
|
else {
|
|
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
}
|
|
|
|
if ((GetFileType(hOut) & ~FILE_TYPE_REMOTE) == FILE_TYPE_CHAR) {
|
|
DWORD cchWChar;
|
|
WCHAR szBufferMessage[1024];
|
|
|
|
vswprintf( szBufferMessage, format, argptr );
|
|
cchWChar = wcslen(szBufferMessage);
|
|
WriteConsoleW(hOut, szBufferMessage, cchWChar, &cchWChar, NULL);
|
|
return cchWChar;
|
|
}
|
|
|
|
return vfwprintf(str, format, argptr);
|
|
}
|