|
|
/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
mspdebug.cpp
Abstract:
This module contains the debugging support for the MSPs.
--*/
#include "precomp.h"
#pragma hdrstop
#include <stdio.h>
#include <strsafe.h>
//
// no need to build this code if MSPLOG is not defined
//
#ifdef MSPLOG
#define MAXDEBUGSTRINGLENGTH 513
static DWORD sg_dwTraceID = INVALID_TRACEID;
static const ULONG MAX_KEY_LENGTH = 100;
static const DWORD DEFAULT_DEBUGGER_MASK = 0xffff0000;
static char sg_szTraceName[MAX_KEY_LENGTH]; // saves name of dll
static DWORD sg_dwTracingToDebugger = 0;static DWORD sg_dwTracingToConsole = 0;static DWORD sg_dwTracingToFile = 0;static DWORD sg_dwDebuggerMask = 0;
//
// this flag indicates whether any tracing needs to be done at all
//
BOOL g_bMSPBaseTracingOn = FALSE;
BOOL NTAPI MSPLogRegister(LPCTSTR szName){ HKEY hTracingKey;
char szTracingKey[MAX_KEY_LENGTH];
const char szDebuggerTracingEnableValue[] = "EnableDebuggerTracing"; const char szConsoleTracingEnableValue[] = "EnableConsoleTracing"; const char szFileTracingEnableValue[] = "EnableFileTracing"; const char szTracingMaskValue[] = "ConsoleTracingMask";
sg_dwTracingToDebugger = 0; sg_dwTracingToConsole = 0; sg_dwTracingToFile = 0;
#ifdef UNICODE
HRESULT hr = StringCchPrintfA(szTracingKey, MAX_KEY_LENGTH, "Software\\Microsoft\\Tracing\\%ls", szName);#else
HRESULT hr = StringCchPrintfA(szTracingKey, MAX_KEY_LENGTH, "Software\\Microsoft\\Tracing\\%s", szName);#endif
if (FAILED(hr)) {
//
// if this assert fires, the chances are the name string passed to us
// by the MSP is too long. the msp developer needs to address that.
//
_ASSERTE(FALSE); return FALSE; }
_ASSERTE(sg_dwTraceID == INVALID_TRACEID);
if ( ERROR_SUCCESS == RegOpenKeyExA(HKEY_LOCAL_MACHINE, szTracingKey, 0, KEY_READ, &hTracingKey) ) { DWORD dwDataSize = sizeof (DWORD); DWORD dwDataType;
LONG lRc = RegQueryValueExA(hTracingKey, szDebuggerTracingEnableValue, 0, &dwDataType, (LPBYTE) &sg_dwTracingToDebugger, &dwDataSize);
if (ERROR_SUCCESS != lRc) { sg_dwTracingToDebugger = 0; }
lRc = RegQueryValueExA(hTracingKey, szConsoleTracingEnableValue, 0, &dwDataType, (LPBYTE) &sg_dwTracingToConsole, &dwDataSize);
if (ERROR_SUCCESS != lRc) { sg_dwTracingToConsole = 0; }
lRc = RegQueryValueExA(hTracingKey, szFileTracingEnableValue, 0, &dwDataType, (LPBYTE) &sg_dwTracingToFile, &dwDataSize);
if (ERROR_SUCCESS != lRc) { sg_dwTracingToFile = 0; }
lRc = RegQueryValueExA(hTracingKey, szTracingMaskValue, 0, &dwDataType, (LPBYTE) &sg_dwDebuggerMask, &dwDataSize);
if (ERROR_SUCCESS != lRc) { sg_dwDebuggerMask = DEFAULT_DEBUGGER_MASK;
}
RegCloseKey (hTracingKey);
} else {
//
// the key could not be opened. in case the key does not exist,
// register with rtutils so that the reg keys get created
//
#ifdef UNICODE
hr = StringCchPrintfA(sg_szTraceName, MAX_KEY_LENGTH, "%ls", szName);#else
hr = StringCchPrintfA(sg_szTraceName, MAX_KEY_LENGTH, "%s", szName);#endif
if (FAILED(hr)) {
//
// if this assert fires, the chances are the name string passed to us
// by the MSP is too long. the msp developer needs to address that.
//
_ASSERTE(FALSE);
return FALSE; }
//
// tracing should not have been initialized
//
sg_dwTraceID = TraceRegister(szName);
if (sg_dwTraceID != INVALID_TRACEID) { g_bMSPBaseTracingOn = TRUE; }
return TRUE; }
//
// are we asked to do any tracing at all?
//
if ( (0 != sg_dwTracingToDebugger) || (0 != sg_dwTracingToConsole ) || (0 != sg_dwTracingToFile ) ) {
//
// see if we need to register with rtutils
//
if ( (0 != sg_dwTracingToConsole ) || (0 != sg_dwTracingToFile) ) {
//
// rtutils tracing is enabled. register with rtutils
//
#ifdef UNICODE
hr = StringCchPrintfA(sg_szTraceName, MAX_KEY_LENGTH, "%ls", szName);#else
hr = StringCchPrintfA(sg_szTraceName, MAX_KEY_LENGTH, "%s", szName);#endif
if (FAILED(hr)) {
//
// if this assert fires, the chances are the name string passed to us
// by the MSP is too long. the msp developer needs to address that.
//
_ASSERTE(FALSE);
return FALSE; }
//
// tracing should not have been initialized
//
_ASSERTE(sg_dwTraceID == INVALID_TRACEID);
//
// register
//
sg_dwTraceID = TraceRegister(szName); }
//
// if debugger tracing, or succeeded registering with rtutils, we are all set
//
if ( (0 != sg_dwTracingToDebugger) || (sg_dwTraceID != INVALID_TRACEID) ) {
//
// some tracing is enabled. set the global flag
//
g_bMSPBaseTracingOn = TRUE;
return TRUE; } else {
//
// registration did not go through and debugger logging is off
//
return FALSE; } }
//
// logging is not enabled. nothing to do
//
return TRUE;}
void NTAPI MSPLogDeRegister(){ if (g_bMSPBaseTracingOn) { sg_dwTracingToDebugger = 0; sg_dwTracingToConsole = 0; sg_dwTracingToFile = 0;
//
// if we registered tracing, unregister now
//
if ( sg_dwTraceID != INVALID_TRACEID ) { TraceDeregister(sg_dwTraceID); sg_dwTraceID = INVALID_TRACEID; } }}
void NTAPI LogPrint(IN DWORD dwDbgLevel, IN LPCSTR lpszFormat, IN ...)/*++
Routine Description:
Formats the incoming debug message & calls TraceVprintfEx to print it.
Arguments:
dwDbgLevel - The type of the message.
lpszFormat - printf-style format string, followed by appropriate list of arguments
Return Value:
--*/{ static char * message[] = { "ERROR", "WARNING", "INFO", "TRACE", "EVENT", "INVALID TRACE LEVEL" };
char szTraceBuf[MAXDEBUGSTRINGLENGTH]; DWORD dwIndex;
if ( ( sg_dwTracingToDebugger > 0 ) && ( 0 != ( dwDbgLevel & sg_dwDebuggerMask ) ) ) { switch(dwDbgLevel) { case MSP_ERROR: dwIndex = 0; break; case MSP_WARN: dwIndex = 1; break; case MSP_INFO: dwIndex = 2; break; case MSP_TRACE: dwIndex = 3; break; case MSP_EVENT: dwIndex = 4; break; default: dwIndex = 5; break; }
// retrieve local time
SYSTEMTIME SystemTime; GetLocalTime(&SystemTime);
HRESULT hr = StringCchPrintfA(szTraceBuf, MAXDEBUGSTRINGLENGTH, "%s:[%02u:%02u:%02u.%03u,tid=%x:]%s: ", sg_szTraceName, SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond, SystemTime.wMilliseconds, GetCurrentThreadId(), message[dwIndex]);
if (FAILED(hr)) {
//
// if this assert fires, there is a good chance a bug was
// introduced in this function
//
_ASSERTE(FALSE);
return; }
va_list ap; va_start(ap, lpszFormat);
size_t nStringLength = 0; hr = StringCchLengthA(szTraceBuf, MAXDEBUGSTRINGLENGTH, &nStringLength);
if (FAILED(hr)) {
//
// if this assert fires, there is a good chance a bug was
// introduced in this function
//
_ASSERTE(FALSE);
return; }
if (nStringLength >= MAXDEBUGSTRINGLENGTH) { //
// the string is too long, was a bug introduced in this function?
//
_ASSERTE(FALSE);
return; }
hr = StringCchVPrintfA(&szTraceBuf[nStringLength], MAXDEBUGSTRINGLENGTH - nStringLength, lpszFormat, ap );
if (FAILED(hr)) {
//
// the string the msp code is trying to log is too long. assert to
// indicate this, but proceed to logging it (StringCchVPrintfA
// guarantees that in case of ERROR_INSUFFICIENT_BUFFER, the
// string is remain null-terminated).
//
_ASSERTE(FALSE);
if (ERROR_INSUFFICIENT_BUFFER != hr) {
return; } }
hr = StringCchCatA(szTraceBuf, MAXDEBUGSTRINGLENGTH,"\n");
// in case of failure, the string is likely to be too long. debugbreak,
// and proceed to logging, in which case the string will not be ended
// with '\n'
_ASSERTE(SUCCEEDED(hr));
OutputDebugStringA (szTraceBuf);
va_end(ap); }
if (sg_dwTraceID != INVALID_TRACEID) { if ( ( sg_dwTracingToConsole > 0 ) || ( sg_dwTracingToFile > 0 ) ) { switch(dwDbgLevel) { case MSP_ERROR: dwIndex = 0; break; case MSP_WARN: dwIndex = 1; break; case MSP_INFO: dwIndex = 2; break; case MSP_TRACE: dwIndex = 3; break; case MSP_EVENT: dwIndex = 4; break; default: dwIndex = 5; break; }
HRESULT hr = StringCchPrintfA(szTraceBuf, MAXDEBUGSTRINGLENGTH, "[%s] %s", message[dwIndex], lpszFormat);
if (FAILED(hr)) {
// the string we are trying to log is too long (or there is an
// unexpected error). do not proceed to logging, since we
// cannot afford to loose the formatting information contained
// in the string -- that would confuse TraceVprintfExA()
_ASSERTE(FALSE);
return; }
va_list arglist; va_start(arglist, lpszFormat); TraceVprintfExA(sg_dwTraceID, dwDbgLevel | TRACE_USE_MSEC, szTraceBuf, arglist); va_end(arglist); } }}
#endif // MSPLOG
// eof
|
