//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: T R A C E . C P P
//
// Contents: The actual tracing code (loading from ini, calling the
// trace routines, etc.
//
// Notes:
//
// Author: jeffspr 9 Apr 1997
//
//----------------------------------------------------------------------------
#include <pch.h>
#pragma hdrstop
#ifdef ENABLETRACE
#include <stdio.h>
#include "ncdebug.h"
#include "ncbase.h"
#define DBG_BUFFER_SIZE_SMALL (256)
#define DBG_BUFFER_SIZE_LARGE (1024)
//---[ CTracing class ]-------------------------------------------------------
//
// Don't give this class a constructor or destructor. We declare a global
// (static to this module) instance of this class and, by definition, static
// variables are automatically initialized to zero.
//
class CTracing
{
public:
CTracing();
// Initialize/Deinitialize this class
//
HRESULT HrInit();
HRESULT HrUnInit();
VOID Trace( TraceTagId ttid,
PCSTR pszaTrace );
private:
BOOL m_fInitialized; // Has the object been initialized
BOOL m_fAttemptedLogFileOpen; // Already attempted to open log
BOOL m_fDisableLogFile; // Disable use of file logging?
HANDLE m_hLogFile; // Handle for debug output file
HANDLE m_hMutex;
CHAR m_szLogFilePath[MAX_PATH+1]; // File for debug output
BOOL m_fDebugFlagsLoaded; // Have these been loaded yet.
VOID CorruptionCheck(); // Validate the tracetag structure
HRESULT HrLoadOptionsFromIniFile();
HRESULT HrLoadSectionsFromIniFile();
HRESULT HrLoadDebugFlagsFromIniFile();
HRESULT HrWriteDebugFlagsToIniFile();
HRESULT HrOpenLogFile();
HRESULT HrProcessTagSection(TraceTagElement * ptte);
HRESULT HrGetPrivateProfileString( PCSTR lpAppName,
PCSTR lpKeyName,
PCSTR lpDefault,
PSTR lpReturnedString,
DWORD nSize,
PCSTR lpFileName,
DWORD * pcchReturn );
BOOL FIniFileExists();
};
//---[ Static Variables ]-----------------------------------------------------
static CTracing g_Tracing; // Our global tracing object
//---[ Constants ]------------------------------------------------------------
static const CHAR c_szaDebugIniFileName[] = "upnpdbg.ini"; // .INI file
static const CHAR c_szaTraceLogFileName[] = "nctrace.log"; // .LOG file
// constants for the INI file labels
static const CHAR c_szaOptions[] = "Options";
static const CHAR c_szaLogFilePath[] = "LogFilePath";
static const CHAR c_szaDisableLogFile[] = "DisableLogFile";
static const CHAR c_szaLogFileMutex[] = "UPNP_LOG_FILE_MUTEX";
const INT c_iDefaultDisableLogFile = 0;
//+---------------------------------------------------------------------------
//
// Function: HrInitTracing
//
// Purpose: Initialize the Tracing object and other random data.
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 9 Apr 1997
//
// Notes:
//
HRESULT HrInitTracing()
{
HRESULT hr = g_Tracing.HrInit();
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrUnInitTracing
//
// Purpose: Uninitialize the tracing object.
//
// Arguments:
// (none)
//
// Returns: S_OK or a valid Win32 HRESULT
//
// Author: jeffspr 14 Apr 1997
//
// Notes:
//
HRESULT HrUnInitTracing()
{
HRESULT hr = g_Tracing.HrUnInit();
return hr;
}
const DWORD TI_HRESULT = 0x00000001;
const DWORD TI_WIN32 = 0x00000002;
const DWORD TI_IGNORABLE = 0x00000004;
//+---------------------------------------------------------------------------
//
// Function: TraceInternal
//
// Purpose: The one and only place that a string to be traced is formed
// and traced.
//
// Arguments:
//
// Returns: nothing.
//
// Author: shaunco 13 Mar 1998
//
// Notes: Restructured from lots of other code that was added to this
// module over the past year.
//
VOID
TraceInternal (
TRACETAGID ttid,
PCSTR pszaFile,
INT nLine,
DWORD dwFlags,
PCSTR pszaCallerText,
DWORD dwErrorCode)
{
// If this tracetag is turned off, don't do anything.
//
if (!g_TraceTags[ttid].fOutputDebugString &&
!g_TraceTags[ttid].fOutputToFile)
{
return;
}
BOOL fError = dwFlags & (TI_HRESULT | TI_WIN32);
BOOL fIgnorable = dwFlags & TI_IGNORABLE;
HRESULT hr = (dwFlags & TI_HRESULT) ? dwErrorCode : S_OK;
DWORD dwWin32Error = (dwFlags & TI_WIN32) ? dwErrorCode : ERROR_SUCCESS;
// Ignore if told and we're not set to trace ignored errors or warnings.
//
if (fError && fIgnorable &&
!FIsDebugFlagSet (dfidShowIgnoredErrors) &&
!FIsDebugFlagSet (dfidExtremeTracing))
{
return;
}
// Don't do anything if we're tracing for an error and we don't have one,
// unless the "Extreme Tracing" flag is on, in which case we trace
// everything in the world (for debugger use only, really)
// This is the path taken by TraceError ("...", S_OK) or
// TraceLastWin32Error when there is no last Win32 error.
//
if (fError && !dwErrorCode && !FIsDebugFlagSet(dfidExtremeTracing))
{
return;
}
CHAR szaBuf [DBG_BUFFER_SIZE_LARGE];
PSTR pcha = szaBuf;
// Form the prefix, process id and thread id.
//
static const CHAR c_szaFmtPrefix [] = "UPNPDBG";
lstrcpyA (pcha, c_szaFmtPrefix);
pcha += lstrlenA (c_szaFmtPrefix);
// Add process and thread ids if the debug flags indicate to do so.
//
if (FIsDebugFlagSet (dfidShowProcessAndThreadIds))
{
static const CHAR c_szaFmtPidAndTidDecimal [] = " %03d.%03d";
static const CHAR c_szaFmtPidAndTidHex [] = " 0x%04x.0x%04x";
LPCSTR pszaFmtPidAndTid = NULL;
if (FIsDebugFlagSet (dfidShowIdsInHex))
{
pszaFmtPidAndTid = c_szaFmtPidAndTidHex;
}
else
{
pszaFmtPidAndTid = c_szaFmtPidAndTidDecimal;
}
pcha += wsprintfA (pcha, pszaFmtPidAndTid,
GetCurrentProcessId (),
GetCurrentThreadId ());
}
// Add a time stamp if the debug flags indicate to do so.
//
if (FIsDebugFlagSet (dfidTracingTimeStamps))
{
static const CHAR c_szaFmtTime [] = " [%02d:%02d:%02d.%03d]";
SYSTEMTIME stLocal;
GetLocalTime (&stLocal);
pcha += wsprintfA (pcha, c_szaFmtTime,
stLocal.wHour,
stLocal.wMinute,
stLocal.wSecond,
stLocal.wMilliseconds);
}
// Add a severity indicator if this trace is for an error or warning.
//
if (fError || (ttidError == ttid))
{
static const CHAR c_szaSevIgnored [] = " Ignored:";
static const CHAR c_szaSevError [] = " *ERROR*:";
static const CHAR c_szaSevWarning [] = " Warning:";
PCSTR pszaSev = NULL;
if (fError && SUCCEEDED(hr) && !dwWin32Error && !fIgnorable)
{
pszaSev = c_szaSevWarning;
}
else
{
if (fIgnorable && FIsDebugFlagSet (dfidShowIgnoredErrors))
{
pszaSev = c_szaSevIgnored;
}
else
{
pszaSev = c_szaSevError;
}
}
Assert (pszaSev);
lstrcatA (pcha, pszaSev);
pcha += lstrlenA (pszaSev);
}
// Add the tracetag short name. Don't do this for ttidError if
// we already have the severity indicator from above.
//
if (ttid && (ttid < g_nTraceTagCount) && (ttid != ttidError))
{
static const CHAR c_szaFmtTraceTag [] = " (%s)";
pcha += wsprintfA (pcha, c_szaFmtTraceTag,
g_TraceTags[ttid].szShortName);
}
int nBytesCopied;
int nBytesRemaining;
// monitor bytes remaining from here on out...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
// Add the caller's text.
//
if (pszaCallerText)
{
static const CHAR c_szaFmtCallerText [] = " %s";
// copy as many bytes as possible
nBytesCopied = _snprintf (pcha,
nBytesRemaining,
c_szaFmtCallerText,
pszaCallerText);
// check for overflow
if (nBytesCopied >= 0)
{
// increment pointer
pcha += nBytesCopied;
Assert (pcha > szaBuf);
if ('\n' == *(pcha-1))
{
pcha--;
*pcha = 0;
}
// update the number of bytes remaining...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
}
else
{
// modify count
nBytesRemaining = 0;
}
}
// Add descriptive error text if this is an error and we can get some.
//
if ((nBytesRemaining > 0) && (FAILED(hr) || dwWin32Error))
{
BOOL fFacilityWin32 = (FACILITY_WIN32 == HRESULT_FACILITY(hr));
// dwError will be the error code we pass to FormatMessage. It may
// come from hr or dwWin32Error. Give preference to hr.
//
DWORD dwError = 0;
if (fFacilityWin32)
{
dwError = HRESULT_CODE(hr);
}
else if (FAILED(hr))
{
dwError = hr;
}
else
{
dwError = dwWin32Error;
}
Assert (dwError);
if (!FIsDebugFlagSet (dfidNoErrorText))
{
PSTR pszaErrorText = NULL;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL, dwError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
(PSTR)&pszaErrorText, 0, NULL);
if (pszaErrorText)
{
// Strip off newline characters.
//
PSTR pchText = pszaErrorText;
while (*pchText && (*pchText != '\r') && (*pchText != '\n'))
{
pchText++;
}
*pchText = 0;
// Add the error text.
//
static const CHAR c_szaFmtErrorText [] = " [%s]";
// copy as many bytes as possible
nBytesCopied = _snprintf (pcha,
nBytesRemaining,
c_szaFmtErrorText,
pszaErrorText);
// check for overflow
if (nBytesCopied >= 0)
{
// increment pointer
pcha += nBytesCopied;
// update the number of bytes remaining...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
}
else
{
// modify count
nBytesRemaining = 0;
}
LocalFree (pszaErrorText);
}
}
// Add the Win32 error code.
//
if ((nBytesRemaining > 0) && (fFacilityWin32 || dwWin32Error))
{
static const CHAR c_szaFmtWin32Error [] = " Win32=%d,0x%08X";
// copy as many bytes as possible
nBytesCopied = _snprintf (pcha,
nBytesRemaining,
c_szaFmtWin32Error,
dwError, dwError);
// check for overflow
if (nBytesCopied >= 0)
{
// increment pointer
pcha += nBytesCopied;
// update the number of bytes remaining...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
}
else
{
// modify count
nBytesRemaining = 0;
}
}
}
// Add the HRESULT.
//
if ((nBytesRemaining > 0) && (S_OK != hr))
{
static const CHAR c_szaFmtHresult [] = " hr=0x%08X";
// copy as many bytes as possible
nBytesCopied = _snprintf (pcha,
nBytesRemaining,
c_szaFmtHresult,
hr);
// check for overflow
if (nBytesCopied >= 0)
{
// increment pointer
pcha += nBytesCopied;
// update the number of bytes remaining...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
}
else
{
// modify count
nBytesRemaining = 0;
}
}
// Add the file and line.
//
if ((nBytesRemaining > 0) && (pszaFile))
{
static const CHAR c_szaFmtFileAndLine [] = " File:%s,%d";
// copy as many bytes as possible
nBytesCopied = _snprintf (pcha,
nBytesRemaining,
c_szaFmtFileAndLine,
pszaFile, nLine);
// check for overflow
if (nBytesCopied >= 0)
{
// increment pointer
pcha += nBytesCopied;
// update the number of bytes remaining...
nBytesRemaining = sizeof(szaBuf) - (pcha - szaBuf);
}
else
{
// modify count
nBytesRemaining = 0;
}
}
// check for full string
if (nBytesRemaining > 2)
{
lstrcatA (pcha, "\n");
}
else
{
// add new line & terminate full string
szaBuf[sizeof(szaBuf) - 2] = '\n';
szaBuf[sizeof(szaBuf) - 1] = '\0';
}
g_Tracing.Trace (ttid, szaBuf);
// Now that the message is on the debugger, break if we have an error
// and the debug flag to break on error is set.
//
if ((FAILED(hr) || dwWin32Error || (ttidError == ttid)) &&
!fIgnorable && FIsDebugFlagSet(dfidBreakOnError))
{
DebugBreak();
}
}
//+---------------------------------------------------------------------------
//
// Function: TraceErrorFn
//
// Purpose: Output debug trace of an HRESULT, allowing an additional
// caller-defined error string.
//
// Arguments:
// sz [] Caller-defined additional error text
// hr [] The error HRESULT.
//
// Returns:
//
// Author: jeffspr 14 Apr 1997
//
// Notes:
//
VOID
WINAPI
TraceErrorFn (
PCSTR pszaFile,
INT nLine,
PCSTR psza,
HRESULT hr)
{
TraceInternal (ttidError, pszaFile, nLine, TI_HRESULT, psza, hr);
}
VOID
WINAPI
TraceResultFn (
PCSTR pszaFile,
INT nLine,
PCSTR psza,
BOOL f)
{
if (!f)
{
TraceInternal (ttidError, pszaFile, nLine, TI_WIN32, psza,
GetLastError());
}
}
//+---------------------------------------------------------------------------
//
// Function: TraceErrorOptionalFn
//
// Purpose: Implements TraceErrorOptional macro
//
// Arguments:
// pszaFile [in] __FILE__ value
// nLine [in] __LINE__ value
// psza [in] String to trace.
// hr [in] HRESULT value to trace.
// fOpt [in] TRUE if error should be treated as optional, FALSE if
// ERROR is not optional and should be reported thru
// TraceError().
//
// Returns: Nothing.
//
// Author: danielwe 12 May 1997
//
// Notes:
//
VOID
WINAPI
TraceErrorOptionalFn (
PCSTR pszaFile,
INT nLine,
PCSTR psza,
HRESULT hr,
BOOL fIgnorable)
{
DWORD dwFlags = TI_HRESULT;
if (fIgnorable)
{
dwFlags |= TI_IGNORABLE;
}
TraceInternal (ttidError, pszaFile, nLine, dwFlags, psza, hr);
}
//+---------------------------------------------------------------------------
//
// Function: TraceErrorSkipFn
//
// Purpose: Implements TraceErrorOptional macro
//
// Arguments:
// pszaFile [in] __FILE__ value
// nLine [in] __LINE__ value
// psza [in] String to trace.
// hr [in] HRESULT value to trace.
// c [in] count of pass-through Hresults. if hr is any of these
// the error is treated as optional.
// ... [in] list of hresults.
//
// Returns: Nothing.
//
// Author: sumitc 08 Jan 1998
//
// Notes:
//
VOID WINAPI
TraceErrorSkipFn (
PCSTR pszaFile,
INT nLine,
PCSTR psza,
HRESULT hr,
UINT c, ...)
{
va_list valMarker;
BOOL fIgnorable = FALSE;
va_start(valMarker, c);
for (UINT i = 0; i < c; ++i)
{
fIgnorable = (va_arg(valMarker, HRESULT) == hr);
if (fIgnorable)
{
break;
}
}
va_end(valMarker);
DWORD dwFlags = TI_HRESULT;
if (fIgnorable)
{
dwFlags |= TI_IGNORABLE;
}
TraceInternal (ttidError, pszaFile, nLine, dwFlags, psza, hr);
}
//+---------------------------------------------------------------------------
//
// Function: TraceLastWin32ErrorFn
//
// Purpose: Trace the last Win32 error, which we get with GetLastError().
// Not a whole lot to it.
//
// Arguments:
// sz [] Additional error text.
//
// Returns:
//
// Author: jeffspr 14 Apr 1997
//
// Notes:
//
VOID
WINAPIV
TraceLastWin32ErrorFn (
PCSTR pszaFile,
INT nLine,
PCSTR psza)
{
TraceInternal (ttidError, pszaFile, nLine, TI_WIN32, psza, GetLastError());
}
//+---------------------------------------------------------------------------
//
// Function: TraceHr
//
// Purpose: Generic replacement for the TraceErrorOptional, TraceError,
// and a couple other random functions.
//
// Arguments:
// ttid [] TraceTag to use for the debug output
// pszaFile [] Source file to log
// nLine [] Line number to log
// hr [] Error to log
// fIgnorable [] Ignore this error? (The optional bit)
// pszaFmt [] Format of the vargs
//
// Returns:
//
// Author: jeffspr 10 Oct 1997
//
// Notes:
//
VOID
WINAPIV
TraceHr (
TRACETAGID ttid,
PCSTR pszaFile,
INT nLine,
HRESULT hr,
BOOL fIgnorable,
PCSTR pszaFmt,
...)
{
// If this tracetag is turned off, don't do anything.
//
if (!g_TraceTags[ttid].fOutputDebugString &&
!g_TraceTags[ttid].fOutputToFile)
{
return;
}
CHAR szaBuf [DBG_BUFFER_SIZE_SMALL];
// Build the string from the varg list
//
va_list valMarker;
va_start (valMarker, pszaFmt);
// copy as many bytes as possible
_vsnprintf (szaBuf, sizeof(szaBuf), pszaFmt, valMarker);
// terminate full string
szaBuf[sizeof(szaBuf) - 1] = '\0';
va_end (valMarker);
DWORD dwFlags = TI_HRESULT;
if (fIgnorable)
{
dwFlags |= TI_IGNORABLE;
}
TraceInternal (ttid, pszaFile, nLine, dwFlags, szaBuf, hr);
}
//+---------------------------------------------------------------------------
//
// Function: TraceTag
//
// Purpose: Output a debug trace to one or more trace targets (ODS,
// File, COM port, etc.). This function determines the targets
// and performs the actual trace.
//
// Arguments:
// ttid [] TraceTag to use for the debug output
// pszaFmt [] Format of the vargs.
//
// Returns:
//
// Author: jeffspr 14 Apr 1997
//
// Notes:
//
VOID
WINAPIV
TraceTag (
TRACETAGID ttid,
PCSTR pszaFmt,
...)
{
// If this tracetag is turned off, don't do anything.
//
if (!g_TraceTags[ttid].fOutputDebugString &&
!g_TraceTags[ttid].fOutputToFile)
{
return;
}
CHAR szaBuf [DBG_BUFFER_SIZE_SMALL];
// Build the string from the varg list
//
va_list valMarker;
va_start (valMarker, pszaFmt);
// copy as many bytes as possible
_vsnprintf (szaBuf, sizeof(szaBuf), pszaFmt, valMarker);
// terminate full string
szaBuf[sizeof(szaBuf) - 1] = '\0';
va_end (valMarker);
TraceInternal (ttid, NULL, 0, 0, szaBuf, 0);
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::CTracing
//
// Purpose: Constructor for CTracing. Initialize all vars.
//
// Arguments:
// (none)
//
// Returns:
//
// Author: jeffspr 23 Jan 1999
//
// Notes:
//
CTracing::CTracing()
{
m_fInitialized = FALSE; // Has the object been initialized
m_fAttemptedLogFileOpen = FALSE; // Already attempted to open log
m_fDisableLogFile = FALSE; // Disable use of file logging?
m_hLogFile = NULL; // Handle for debug output file
m_szLogFilePath[0] = '\0'; // File for debug output
m_fDebugFlagsLoaded = FALSE; // Have these been loaded yet.
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrInit
//
// Purpose: Initialize the CTracing object.
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 9 Apr 1997
//
// Notes: This should get called from some standard exe initialization
// point. And make sure to call HrDeinit when you're done, eh?
//
HRESULT CTracing::HrInit()
{
HRESULT hr = S_OK;
AssertSz(!m_fInitialized,
"CTracing::HrInit -- Let's not go overboard. Already initialized");
// Temporarily set this so the called functions don't believe that we're
// uninitialized. At Exit, if we fail, we'll set it back so no-one tries
// to call these functions when uninitialized.
//
m_fInitialized = TRUE;
// Check for corruptions in the tracing structure. This can't fail, but
// it will send up asserts all over the place if something is amiss.
//
CorruptionCheck();
// Load the "options" section from the ini file
//
hr = HrLoadOptionsFromIniFile();
if (FAILED(hr))
{
goto Exit;
}
// Load the DebugFlags section from the ini file.
//
hr = HrLoadDebugFlagsFromIniFile();
if (FAILED(hr))
{
goto Exit;
}
// Load the tracetag sections from the ini file.
// Make sure this is called after HrLoadDebugFlagsFromIniFile(),
// as those options will affect the tracetag sections (we also
// assert on this)
//
hr = HrLoadSectionsFromIniFile();
if (FAILED(hr))
{
goto Exit;
}
Exit:
if (FAILED(hr))
{
m_fInitialized = FALSE;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrUnInit
//
// Purpose: Uninitialize the Tracing object
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 12 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrUnInit()
{
HRESULT hr = S_OK;
// Don't assert on m_fInitialized here, because we allow this to
// be called even if initialization failed.
//
if (m_fInitialized)
{
hr = HrWriteDebugFlagsToIniFile();
if (FAILED(hr))
{
// continue on, but I want to know why this is failing.
AssertSz(FALSE, "Whoa, why can't we write the debug flags?");
}
// Close the log file, if there's one open
//
if (m_hLogFile)
{
CloseHandle(m_hLogFile);
m_hLogFile = NULL;
m_fAttemptedLogFileOpen = FALSE;
}
if (m_hMutex)
{
CloseHandle(m_hMutex);
}
// Mark us as being uninitialized.
//
m_fInitialized = FALSE;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrGetPrivateProfileString
//
// Purpose:
//
// Arguments:
// lpAppName [] points to section name
// lpKeyName [] points to key name
// lpDefault [] points to default string
// lpReturnedString [] points to destination buffer
// nSize [] size of destination buffer
// lpFileName [] points to initialization filename
// pcchReturn return buffer for the old Win32 API return code
//
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 12 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrGetPrivateProfileString( PCSTR lpAppName,
PCSTR lpKeyName,
PCSTR lpDefault,
PSTR lpReturnedString,
DWORD nSize,
PCSTR lpFileName,
DWORD* pcchReturn
)
{
HRESULT hr = S_OK;
Assert(m_fInitialized);
// Assert on the known conditions required for this API call
//
Assert(lpDefault);
Assert(lpFileName);
// Call the Win32 API
//
DWORD dwGPPSResult = GetPrivateProfileStringA(
lpAppName,
lpKeyName,
lpDefault,
lpReturnedString,
nSize,
lpFileName);
// Check to see if we've gotten a string-size error
if (lpAppName && lpKeyName)
{
// If we get back (nSize - 1), then our string buffer wasn't
// large enough
//
if (dwGPPSResult == (nSize - 1))
{
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
goto Exit;
}
}
else
{
// Since either of the app name or key name are NULL, then
// we're supposed to be receiving a doubly-NULL terminated
// list of strings. If we're at (nSize - 2), that means
// our buffer was too small.
//
if (dwGPPSResult == (nSize - 2))
{
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
goto Exit;
}
}
Exit:
*pcchReturn = dwGPPSResult;
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrLoadOptionsFromIniFile
//
// Purpose: Load the options section from the ini file, and set our
// state accordingly
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 10 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrLoadOptionsFromIniFile()
{
HRESULT hr = S_OK;
DWORD cchReturnBufferSize = 0;
CHAR szaLogFilePath[MAX_PATH+1] = { 0 };
DWORD dwTempPathLength = 0;
// Get the explicit log file path, if any. If it doesn't exist, then
// use the default path, which is the temp file path plus the default
// trace file name
//
// Get the location of the "temporary files" path
dwTempPathLength = GetTempPathA(MAX_PATH, szaLogFilePath);
if ((dwTempPathLength == 0) ||
(dwTempPathLength > MAX_PATH))
{
TraceLastWin32Error("GetTempPath failure");
hr = HrFromLastWin32Error();
goto Exit;
}
// Tack the log file name onto the end.
//
wsprintfA(m_szLogFilePath, "%s%s", szaLogFilePath, c_szaTraceLogFileName);
// This will overwrite the log file path if one exists in the INI file
//
hr = HrGetPrivateProfileString(
c_szaOptions, // "Options"
c_szaLogFilePath, // "LogFilePath
m_szLogFilePath, // Default string, already filled
m_szLogFilePath, // Return string (same string)
MAX_PATH+1,
c_szaDebugIniFileName,
&cchReturnBufferSize);
if (FAILED(hr))
{
// This should not cause problems with recursive failure, since
// Traces will work regardless of the state of trace initialization.
//
TraceError(
"GetPrivateProfileString failed on Options::LogFilePath", hr);
goto Exit;
}
// Get the "disable log file option". No return code here.
m_fDisableLogFile = GetPrivateProfileIntA(
c_szaOptions, // "Options"
c_szaDisableLogFile, // "DisableLogFile"
c_iDefaultDisableLogFile,
c_szaDebugIniFileName);
if (FAILED(hr))
{
TraceError(
"GetPrivateProfileInt failed on Options::DisableLogFile", hr);
goto Exit;
}
Exit:
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrLoadSectionsFromIniFile
//
// Purpose: Load the individual tracetag sections from the ini file, and
// set our array elements accordingly, defaulting if necessary.
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 10 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrLoadSectionsFromIniFile()
{
HRESULT hr = S_OK;
// Make sure that we've loaded the debug flags first, as they can
// affect each tracetag section
//
Assert(m_fDebugFlagsLoaded);
// Loop through the array and load the data.
//
for (INT nLoop = 0; nLoop < g_nTraceTagCount; nLoop++ )
{
// Process the individual lines from the section
hr = HrProcessTagSection(&(g_TraceTags[nLoop]));
if (FAILED(hr))
{
break;
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrLoadDebugFlagsFromIniFile
//
// Purpose: Load the individual debugflag values from the ini file, and
// set our array elements accordingly, defaulting if necessary.
//
// Arguments:
// (none)
//
// Returns: S_OK or valid Win32 HRESULT
//
// Author: jeffspr 10 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrLoadDebugFlagsFromIniFile()
{
HRESULT hr = S_OK;
INT nLoop;
// Loop through the array and load the data.
//
for (nLoop = 0; nLoop < g_nDebugFlagCount; nLoop++)
{
// Get the enabled file param
//
g_DebugFlags[nLoop].dwValue = GetPrivateProfileIntA(
"DebugFlags",
g_DebugFlags[nLoop].szShortName,
FALSE,
c_szaDebugIniFileName);
}
if (SUCCEEDED(hr))
{
m_fDebugFlagsLoaded = TRUE;
}
return hr;
}
BOOL CTracing::FIniFileExists()
{
BOOL fReturn = TRUE;
CHAR szaPath[MAX_PATH+1] = "";
UINT uiCharsReturned = 0;
HANDLE hFile = INVALID_HANDLE_VALUE;
uiCharsReturned =
GetWindowsDirectoryA(szaPath, MAX_PATH);
if ((uiCharsReturned == 0) || (uiCharsReturned > MAX_PATH))
{
AssertSz(FALSE, "GetWindowsDirectory failed in CTracing::FIniFileExists");
fReturn = FALSE;
goto Exit;
}
lstrcatA (szaPath, "\\");
lstrcatA (szaPath, c_szaDebugIniFileName);
hFile = CreateFileA(
szaPath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
DWORD dwLastError = GetLastError();
if (dwLastError != ERROR_FILE_NOT_FOUND)
{
AssertSz(FALSE, "FIniFileExists failed for some reason other than FILE_NOT_FOUND");
}
fReturn = FALSE;
goto Exit;
}
Exit:
if (hFile)
{
CloseHandle(hFile);
hFile = NULL;
}
return fReturn;
}
HRESULT CTracing::HrWriteDebugFlagsToIniFile()
{
HRESULT hr = S_OK;
// First, check to see if the file exists. If it doesn't, then we don't want
// to write the entries.
//
if (FIniFileExists())
{
// Loop through the array and write the data.
//
for (INT nLoop = 0; nLoop < g_nDebugFlagCount; nLoop++)
{
CHAR szInt[16]; // Sure, it's arbitrary, but it's also OK.
switch(nLoop)
{
// These store a DWORD in its standard form
//
case dfidBreakOnHr:
case dfidBreakOnHrIteration:
case dfidBreakOnIteration:
wsprintfA( szInt, "%d", g_DebugFlags[nLoop].dwValue);
break;
// default are treated as boolean, and stored that way
//
default:
// !! means it will always be 1 or 0.
wsprintfA( szInt, "%d", (!!g_DebugFlags[nLoop].dwValue));
break;
}
// Write the param to the ini file
WritePrivateProfileStringA(
"DebugFlags",
g_DebugFlags[nLoop].szShortName,
szInt,
c_szaDebugIniFileName);
}
}
// For now, this is always S_OK, since there's nothing above that can
// fail.
//
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::HrProcessTagSection
//
// Purpose: Grab the parameters from the ini file. If they're not
// available, then use the settings in default. Note - this
// will always work because ttidDefault will always be the first
// element. If a [default] section wasn't present, then it will
// be using the settings that were in the struct initialization,
// which is also fine.
//
// Arguments:
// ptte [] TraceTag element to load
//
// Returns:
//
// Author: jeffspr 15 Apr 1997
//
// Notes:
//
HRESULT CTracing::HrProcessTagSection( TraceTagElement * ptte )
{
HRESULT hr = S_OK;
AssertSz(m_fInitialized,
"CTracing::HrProcessTagSection. Class not initialized");
AssertSz(ptte, "CTracing::HrProcessTagSection -- invalid ptte");
// Get the output to file param
//
ptte->fOutputToFile = GetPrivateProfileIntA(
ptte->szShortName,
"OutputToFile",
ptte->fVerboseOnly ?
FALSE : g_TraceTags[ttidDefault].fOutputToFile,
c_szaDebugIniFileName);
// Get the OutputDebugString param. Require that the error tag
// always has at least output debug string on.
//
if (ptte->ttid == ttidError)
{
ptte->fOutputDebugString = TRUE;
}
else
{
// Load the OutputToDebug
ptte->fOutputDebugString = GetPrivateProfileIntA(
ptte->szShortName,
"OutputToDebug",
ptte->fVerboseOnly ?
FALSE : g_TraceTags[ttidDefault].fOutputDebugString,
c_szaDebugIniFileName);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::CorruptionCheck
//
// Purpose: Validate the tracetag array. Check to see that the
// shortnames are valid, that the descriptions are valid,
// and that the tracetag elements are not out of order.
// Also verify that the correct number of tracetag elements
// exist.
//
// Arguments:
// (none)
//
// Returns:
//
// Author: jeffspr 15 Apr 1997
//
// Notes:
// (shaunco) 16 Jul 1997: This is #if'defd out until JVert
// gives us a fix for the alpha compiler. It blows up compiling this
// function in retail.
//
// (jeffspr) Tough noogies for JVert - I need this code. Hopefully
// this has been fixed by now.
//
VOID CTracing::CorruptionCheck()
{
INT nLoop = 0;
// Validate the tracetag structure
//
for (nLoop = 0; nLoop < g_nTraceTagCount; nLoop++)
{
// Verify that we're not out of order or missing ttids
//
AssertSz(g_TraceTags[nLoop].ttid == nLoop,
"Invalid ttid in the tracetag structure. Out of order. " \
"CTracing::CorruptionCheck");
AssertSz(g_TraceTags[nLoop].ttid < g_nTraceTagCount,
"Invalid ttid (out of range) in CTracing::CorruptionCheck");
// Validate the shortname (verify not NULL or empty strings)
//
AssertSz(g_TraceTags[nLoop].szShortName,
"Invalid tracetag short name (NULL) in CTracing::CorruptionCheck");
AssertSz(g_TraceTags[nLoop].szShortName[0] != 0,
"Invalid tracetagshort name (empty) in CTracing::CorruptionCheck");
// Validate the descriptions (verify not NULL or empty strings)
//
AssertSz(g_TraceTags[nLoop].szDescription,
"Invalid tracetagdescription in CTracing::CorruptionCheck");
AssertSz(g_TraceTags[nLoop].szDescription[0] != 0,
"Invalid tracetagdescription (empty) in CTracing::CorruptionCheck");
}
// Validate the debug flags structure
//
for (nLoop = 0; nLoop < g_nDebugFlagCount; nLoop++)
{
// Verify that we're not out of order or missing dfids
//
AssertSz(g_DebugFlags[nLoop].dfid == nLoop,
"Invalid dfid in the debugflag structure. Out of order. " \
"CTracing::CorruptionCheck");
AssertSz(g_DebugFlags[nLoop].dfid < g_nDebugFlagCount,
"Invalid dfid (out of range) in CTracing::CorruptionCheck");
// Validate the shortname (verify not NULL or empty strings)
//
AssertSz(g_DebugFlags[nLoop].szShortName,
"Invalid debug flag short name (NULL) in CTracing::CorruptionCheck");
AssertSz(g_DebugFlags[nLoop].szShortName[0] != 0,
"Invalid debug flag short name (empty) in CTracing::CorruptionCheck");
// Validate the descriptions (verify not NULL or empty strings)
//
AssertSz(g_DebugFlags[nLoop].szDescription,
"Invalid debug flag description in CTracing::CorruptionCheck");
AssertSz(g_DebugFlags[nLoop].szDescription[0] != 0,
"Invalid debug flag description (empty) in CTracing::CorruptionCheck");
}
return;
}
//+---------------------------------------------------------------------------
//
// Member: CTracing::Trace
//
// Purpose: The actual trace call that takes care of doing the output
// to each trace target (file, OutputDebugString, etc.)
//
// Arguments:
// ttid [] The tracetag to use for output
// pszaTrace [] The trace string itself.
//
// Returns:
//
// Author: jeffspr 12 Apr 1997
//
// Notes:
//
VOID CTracing::Trace( TraceTagId ttid,
PCSTR pszaTrace )
{
// HrInit should have called a corruption checker for the entire trace
// block, but we'll check again just to make sure.
//
AssertSz(g_nTraceTagCount > ttid, "ttid out of range in CTracing::Trace");
AssertSz(g_TraceTags[ttid].ttid == ttid,
"TraceTag structure is corrupt in CTracing::Trace");
// If they want debug string output
//
if (g_TraceTags[ttid].fOutputDebugString)
{
// Then output the string
//
OutputDebugStringA(pszaTrace);
}
// If they want file output
if (g_TraceTags[ttid].fOutputToFile)
{
if (!m_hLogFile)
{
// Assuming that we haven't already tried to open the file
// and failed, open it.
if (!m_fAttemptedLogFileOpen)
{
HRESULT hr = HrOpenLogFile();
if (FAILED(hr))
{
AssertSz(FALSE, "Failed to open log file for tracing. No, "
"this isn't a coding error, but hey, figured that "
"you'd want to know...");
}
}
}
// If we were already open, or the open has now succeeded, do the
// trace
//
if (m_hLogFile)
{
Assert(pszaTrace);
// Since pszTrace is guaranteed to be a single-byte trace, we
// don't need to do the WCHAR multiply on the length, just
// a char multiply.
//
DWORD dwBytesToWrite = lstrlenA(pszaTrace) * sizeof(CHAR);
DWORD dwBytesWritten = 0;
BOOL fWriteResult = FALSE;
WaitForSingleObject(m_hMutex, INFINITE);
fWriteResult = WriteFile(
m_hLogFile, // handle to file to write to
pszaTrace, // pointer to data to write to file
dwBytesToWrite, // size of trace
&dwBytesWritten, // Bytes actually written.
NULL ); // No overlapped
ReleaseMutex(m_hMutex);
if (!fWriteResult || (dwBytesToWrite != dwBytesWritten))
{
AssertSz(FALSE, "CTracing failure: Can't write to log file."
" Can't trace or we'll be recursing on this failure.");
}
}
}
}
HRESULT CTracing::HrOpenLogFile()
{
HRESULT hr = S_OK;
SECURITY_ATTRIBUTES sa = {0};
SECURITY_DESCRIPTOR sd = {0};
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = FALSE;
sa.lpSecurityDescriptor = &sd;
AssertSz(m_fInitialized,
"CTracing not initialized in HrOpenLogFile()");
AssertSz(!m_hLogFile,
"File already open before call to HrOpenLogFile()");
// Mark us as having attempted to open the file, so we don't call this
// function everytime we log, if we can't open it.
//
m_fAttemptedLogFileOpen = TRUE;
m_hMutex = CreateMutexA(&sa, FALSE, c_szaLogFileMutex);
if (!m_hMutex)
{
hr = HrFromLastWin32Error();
goto Exit;
}
WaitForSingleObject(m_hMutex, INFINITE);
// $$TODO (jeffspr) - Allow flags in the Options section of the ini
// file specify the create flags and attributes, which would allow
// us to control the overwriting of log files and/or the write-through
// properties.
//
// Actually open the file, creating if necessary.
//
m_hLogFile = CreateFileA(
m_szLogFilePath, // Pointer to name of file
GENERIC_READ | GENERIC_WRITE, // access (read-write) mode
FILE_SHARE_READ | FILE_SHARE_WRITE, // share mode (allow read access)
NULL, // pointer to security attributes
OPEN_ALWAYS, // how to create
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH,
NULL);
if (INVALID_HANDLE_VALUE == m_hLogFile)
{
m_hLogFile = NULL;
hr = HrFromLastWin32Error();
goto ExitAndRelease;
}
SetFilePointer(m_hLogFile, 0, NULL, FILE_END);
ExitAndRelease:
ReleaseMutex(m_hMutex);
Exit:
return hr;
}
#endif // ENABLETRACE