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.
1713 lines
46 KiB
1713 lines
46 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
wsbtrc.cpp
|
|
|
|
Abstract:
|
|
|
|
This component is a trace object.
|
|
|
|
Author:
|
|
|
|
Chuck Bardeen [cbardeen] 29-Oct-1996
|
|
|
|
Revision History:
|
|
|
|
Brian Dodd [brian] 09-May-1996 - Added event logging
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include "time.h"
|
|
|
|
#undef WsbThrow
|
|
#define WsbThrow(hr) throw(hr)
|
|
#include "wsbtrc.h"
|
|
|
|
// Local data
|
|
static WCHAR message[1024]; // Space for formatting a message
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::FinalConstruct(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::FinalConstruct
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
// Set up global values
|
|
g_pWsbTrace = 0;
|
|
g_WsbTraceModules = WSB_TRACE_BIT_NONE;
|
|
|
|
// Establish Base object
|
|
WsbAffirmHr(CComObjectRoot::FinalConstruct() );
|
|
|
|
// Initialize member data
|
|
m_TraceOn = FALSE;
|
|
m_TraceSettings = WSB_TRACE_BIT_NONE;
|
|
m_TraceFileName = OLESTR("");
|
|
m_TraceOutput = WSB_TRACE_OUT_NONE;
|
|
m_CommitEachEntry = FALSE;
|
|
m_TimeStamp = FALSE;
|
|
m_TraceCount = FALSE;
|
|
m_TraceThreadId = FALSE;
|
|
m_TraceFilePointer = INVALID_HANDLE_VALUE;
|
|
m_WrapMode = FALSE;
|
|
m_RegistrySetting = OLESTR("");
|
|
m_TraceEntryExit = g_WsbTraceEntryExit;
|
|
m_LogLevel = g_WsbLogLevel;
|
|
m_TraceFileCopyName = OLESTR("");
|
|
m_TraceMultipleFilePattern = OLESTR("");
|
|
m_TraceMultipleFileCount = 0;
|
|
m_TraceCountHandle = NULL;
|
|
m_pTraceCountGlobal = NULL;
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
void
|
|
CWsbTrace::FinalRelease(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::FinalRelease
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Stop Trace
|
|
StopTrace();
|
|
|
|
// Free base class
|
|
//
|
|
CComObjectRoot::FinalRelease( );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::StartTrace(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::StartTrace
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
if (g_pWsbTrace == 0) {
|
|
//
|
|
// Set global variable for quick checking
|
|
//
|
|
WsbAffirmHr(((IUnknown*)(IWsbTrace *)this)->QueryInterface(IID_IWsbTrace, (void**) &g_pWsbTrace));
|
|
//
|
|
// We don't want the reference count bumped for this global so release it here.
|
|
g_pWsbTrace->Release();
|
|
}
|
|
|
|
|
|
//
|
|
// Get hold of the trace count
|
|
//
|
|
if (m_pTraceCountGlobal == NULL) {
|
|
|
|
m_pTraceCountGlobal = &g_WsbTraceCount;
|
|
|
|
m_TraceCountHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
|
|
NULL,
|
|
PAGE_READWRITE,
|
|
0,
|
|
sizeof(ULONG),
|
|
L"Global\\RemoteStorageTraceCountPrivate"
|
|
);
|
|
if (m_TraceCountHandle == NULL) {
|
|
if (GetLastError() == ERROR_ALREADY_EXISTS) {
|
|
//
|
|
// Already open, just get hold of the mapping
|
|
//
|
|
m_TraceCountHandle = OpenFileMapping(FILE_MAP_WRITE,
|
|
FALSE,
|
|
L"Global\\RemoteStorageTraceCountPrivate");
|
|
} else {
|
|
swprintf( message, OLESTR("CWsbTrace::StartTrace: CreateFileMapping failed %d\n"), GetLastError());
|
|
g_pWsbTrace->Print(message);
|
|
}
|
|
}
|
|
|
|
if (m_TraceCountHandle != NULL) {
|
|
m_pTraceCountGlobal = (PLONG) MapViewOfFile(m_TraceCountHandle,
|
|
FILE_MAP_WRITE,
|
|
0,
|
|
0,
|
|
sizeof(ULONG));
|
|
if (!m_pTraceCountGlobal) {
|
|
CloseHandle(m_TraceCountHandle);
|
|
m_pTraceCountGlobal = &g_WsbTraceCount;
|
|
m_TraceCountHandle = NULL;
|
|
swprintf( message, OLESTR("CWsbTrace::StartTrace: MapViewOfFile failed %d\n"), GetLastError());
|
|
g_pWsbTrace->Print(message);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set local variable to remember the state
|
|
//
|
|
m_TraceOn = TRUE;
|
|
|
|
//
|
|
// If there is a file name defined and file tracing is on
|
|
// Create/open the trace file.
|
|
//
|
|
try {
|
|
|
|
if ((m_TraceOutput & WSB_TRACE_OUT_FILE) &&
|
|
(wcslen(m_TraceFileName) != 0) ) {
|
|
DWORD attributes;
|
|
DWORD bytesReturned;
|
|
USHORT inBuffer = COMPRESSION_FORMAT_DEFAULT;
|
|
DWORD last_error = 0;
|
|
|
|
//
|
|
// If the main file is open, close it.
|
|
//
|
|
if (INVALID_HANDLE_VALUE != m_TraceFilePointer) {
|
|
CloseHandle(m_TraceFilePointer);
|
|
m_TraceFilePointer = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
// Adjust the file name (for multiple trace files)
|
|
AdjustFileNames();
|
|
|
|
//
|
|
// If there is a copy file specified, copy to it
|
|
//
|
|
if (m_TraceOutput & WSB_TRACE_OUT_FILE_COPY) {
|
|
if (!MoveFileEx(m_TraceFileName, m_TraceFileCopyName,
|
|
(MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH))) {
|
|
|
|
// If copy fails, keep going
|
|
last_error = GetLastError();
|
|
swprintf( message, OLESTR("CWsbTrace::StartTrace: MoveFileEx failed:%ld\r\n"),
|
|
last_error);
|
|
g_pWsbTrace->Print(message);
|
|
}
|
|
}
|
|
|
|
// Open/create the trace file
|
|
if (m_CommitEachEntry) {
|
|
attributes = FILE_FLAG_WRITE_THROUGH;
|
|
} else {
|
|
attributes = FILE_ATTRIBUTE_NORMAL;
|
|
}
|
|
m_TraceFilePointer = CreateFile(m_TraceFileName,
|
|
GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL,
|
|
CREATE_ALWAYS, attributes, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_TraceFilePointer) {
|
|
last_error = GetLastError();
|
|
swprintf( message, OLESTR("CWsbTrace::StartTrace: CreateFile failed:%ld\r\n"),
|
|
last_error);
|
|
g_pWsbTrace->Print(message);
|
|
WsbThrow(E_FAIL);
|
|
}
|
|
|
|
// Make the trace file compressed (if possible)
|
|
if (0 == DeviceIoControl(m_TraceFilePointer, FSCTL_SET_COMPRESSION,
|
|
&inBuffer, sizeof(inBuffer), 0, 0, &bytesReturned, 0)) {
|
|
// Failed to make file compressed -- not a fatal error
|
|
last_error = GetLastError();
|
|
swprintf( message,
|
|
OLESTR("CWsbTrace::StartTrace: DeviceIoControl(COMPRESSION) failed:%ld\r\n"),
|
|
last_error);
|
|
g_pWsbTrace->Print(message);
|
|
}
|
|
}
|
|
} WsbCatch( hr );
|
|
|
|
swprintf( message, OLESTR("Trace Started (%d-%ls)\r\n"),
|
|
VER_PRODUCTBUILD, RsBuildVersionAsString(RS_BUILD_VERSION));
|
|
WsbAffirmHr(g_pWsbTrace->Print(message));
|
|
|
|
} WsbCatch (hr);
|
|
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::StopTrace(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::StopTrace
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Set global variable for quick checking
|
|
//
|
|
if (g_pWsbTrace != 0) {
|
|
g_pWsbTrace->Print(OLESTR("Trace Stopped\r\n"));
|
|
//
|
|
// Don't release here.
|
|
//
|
|
//g_pWsbTrace->Release();
|
|
g_pWsbTrace = 0;
|
|
}
|
|
|
|
//
|
|
// Set local variable to remember the state
|
|
//
|
|
m_TraceOn = FALSE;
|
|
|
|
//
|
|
// Close the file handle
|
|
//
|
|
if (m_TraceFilePointer != INVALID_HANDLE_VALUE) {
|
|
CloseHandle(m_TraceFilePointer);
|
|
m_TraceFilePointer = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (m_TraceCountHandle != NULL) {
|
|
BOOL b;
|
|
|
|
CloseHandle(m_TraceCountHandle);
|
|
m_TraceCountHandle = NULL;
|
|
//
|
|
// We should have a macro to assert without
|
|
// throwing HR's
|
|
// After one is added, a good assert here would be:
|
|
// ASSERT(m_pTraceCountGlobal != NULL);
|
|
//
|
|
b = UnmapViewOfFile(m_pTraceCountGlobal);
|
|
//
|
|
// And another here would be:
|
|
// ASSERT(b);
|
|
//
|
|
m_pTraceCountGlobal = NULL;
|
|
}
|
|
|
|
} WsbCatch (hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::AdjustFileNames(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Make sure trace flags are set correctly and parse file names if we
|
|
haven't already. If we're doing multiple trace files (instead of
|
|
wrapping), adjust the trace and copy file names.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
// If we haven't yet, parse file names & set flags.
|
|
if (!(m_TraceOutput & WSB_TRACE_OUT_FLAGS_SET)) {
|
|
OLECHAR *pc_original;
|
|
OLECHAR *pc_bslash;
|
|
CWsbStringPtr str_temp(m_TraceFileName);
|
|
|
|
// Reset flags & file info
|
|
m_TraceOutput &= ~WSB_TRACE_OUT_MULTIPLE_FILES;
|
|
m_TraceOutput &= ~WSB_TRACE_OUT_FILE_COPY;
|
|
m_TraceFileDir = "";
|
|
m_TraceMultipleFilePattern = "";
|
|
m_TraceFileCopyDir = "";
|
|
|
|
// Parse the trace file name. One or more '*'s means we should
|
|
// do multiple trace files. The number of '*'s indicates
|
|
// how many digits to use for the file count. Separate the
|
|
// directory from the file name.
|
|
pc_bslash = wcsrchr(str_temp, OLECHAR('\\'));
|
|
|
|
if (pc_bslash) {
|
|
|
|
*pc_bslash = OLECHAR('\0');
|
|
|
|
// Get the trace directory
|
|
m_TraceFileDir = str_temp;
|
|
m_TraceFileDir.Append("\\");
|
|
|
|
// Point to the file name (which may contain a pattern)
|
|
pc_bslash++;
|
|
} else {
|
|
// No directory specified
|
|
pc_bslash = static_cast<OLECHAR *>(str_temp);
|
|
}
|
|
|
|
// Get the file name
|
|
m_TraceMultipleFilePattern = pc_bslash;
|
|
|
|
// Look for '*'s in the file name
|
|
pc_original = wcschr(pc_bslash, OLECHAR('*'));
|
|
|
|
// Convert a file pattern for use in sprintf
|
|
if (pc_original) {
|
|
OLECHAR format[16];
|
|
OLECHAR *pc_copy;
|
|
int star_count = 0;
|
|
|
|
// Count *'s
|
|
while (OLECHAR('*') == *pc_original) {
|
|
star_count++;
|
|
pc_original++;
|
|
}
|
|
|
|
// Create file name pattern: replace '*'s with printf
|
|
// type format specification (e.g. "%3.3d")
|
|
pc_copy = wcschr(m_TraceMultipleFilePattern, OLECHAR('*'));
|
|
WsbAffirm(pc_copy, E_FAIL);
|
|
*pc_copy = OLECHAR('\0');
|
|
|
|
swprintf(format, OLESTR("%%%d.%dd"), star_count, star_count);
|
|
m_TraceMultipleFilePattern.Append(format);
|
|
m_TraceMultipleFilePattern.Append(pc_original);
|
|
|
|
// Set multiple flag
|
|
m_TraceOutput |= WSB_TRACE_OUT_MULTIPLE_FILES;
|
|
}
|
|
|
|
// If we're doing file copies, set the flag.
|
|
if (wcslen(m_TraceFileCopyName)) {
|
|
m_TraceOutput |= WSB_TRACE_OUT_FILE_COPY;
|
|
|
|
// Get the copy directory
|
|
str_temp = m_TraceFileCopyName;
|
|
pc_bslash = wcsrchr(str_temp, OLECHAR('\\'));
|
|
if (pc_bslash) {
|
|
*pc_bslash = OLECHAR('\0');
|
|
m_TraceFileCopyDir = str_temp;
|
|
m_TraceFileCopyDir.Append("\\");
|
|
|
|
// Point to the copy file name
|
|
pc_bslash++;
|
|
} else {
|
|
pc_bslash = static_cast<OLECHAR *>(str_temp);
|
|
}
|
|
|
|
// If we're not doing multiple trace files, make sure
|
|
// we have a copy file name. (If we are doing multiple
|
|
// trace files, the copy file name is create below.)
|
|
if (!(m_TraceOutput & WSB_TRACE_OUT_MULTIPLE_FILES) &&
|
|
0 == wcslen(pc_bslash)) {
|
|
m_TraceFileCopyName = m_TraceFileCopyDir;
|
|
m_TraceFileCopyName.Append(m_TraceMultipleFilePattern);
|
|
}
|
|
}
|
|
|
|
// Increment file count and indicate flags are set
|
|
m_TraceMultipleFileCount++;
|
|
m_TraceOutput |= WSB_TRACE_OUT_FLAGS_SET;
|
|
}
|
|
|
|
// If we have a file pattern, create the new actual file names
|
|
if (m_TraceOutput & WSB_TRACE_OUT_MULTIPLE_FILES) {
|
|
OLECHAR newName[256];
|
|
|
|
// Create the file name from the pattern and the file count
|
|
wsprintf(newName, m_TraceMultipleFilePattern,
|
|
m_TraceMultipleFileCount);
|
|
|
|
// Combine trace directory and file name
|
|
m_TraceFileName = m_TraceFileDir;
|
|
m_TraceFileName.Append(newName);
|
|
|
|
// Create a new trace file copy name also
|
|
if (m_TraceOutput & WSB_TRACE_OUT_FILE_COPY) {
|
|
m_TraceFileCopyName = m_TraceFileCopyDir;
|
|
m_TraceFileCopyName.Append(newName);
|
|
}
|
|
}
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::SetTraceOn(
|
|
LONGLONG traceElement
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetTraceOn
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Turn on the global trace bits for easy checking
|
|
//
|
|
g_WsbTraceModules = g_WsbTraceModules | traceElement;
|
|
|
|
//
|
|
// Turn on the local trace bits
|
|
//
|
|
m_TraceSettings = g_WsbTraceModules;
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::SetTraceOff(
|
|
LONGLONG traceElement
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetTraceOff
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
//
|
|
// Turn off the global trace bits for easy checking
|
|
//
|
|
g_WsbTraceModules = g_WsbTraceModules & (~traceElement);
|
|
|
|
//
|
|
// Turn on the local trace bits
|
|
//
|
|
m_TraceSettings = g_WsbTraceModules;
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::GetTraceSettings(
|
|
LONGLONG *pTraceElements
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetTraceSettings
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try
|
|
{
|
|
WsbAffirm(pTraceElements != 0, E_POINTER);
|
|
*pTraceElements = g_WsbTraceModules;
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::GetTraceSetting(
|
|
LONGLONG traceElement,
|
|
BOOL *pOn )
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetTraceSetting
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Find the bit and return TRUE if it is set,
|
|
// otherwise return FALSE
|
|
//
|
|
try
|
|
{
|
|
WsbAffirm(pOn != 0, E_POINTER);
|
|
*pOn = FALSE;
|
|
if ((g_WsbTraceModules & traceElement) == traceElement) {
|
|
*pOn = TRUE;
|
|
}
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::DirectOutput(
|
|
ULONG output
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::DirectOutput
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_TraceOutput = output;
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::SetTraceFileControls(
|
|
OLECHAR *pTraceFileName,
|
|
BOOL commitEachEntry,
|
|
LONGLONG maxTraceFileSize,
|
|
OLECHAR *pTraceFileCopyName
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetTraceFileControls
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
if (pTraceFileName) {
|
|
m_TraceFileName = pTraceFileName;
|
|
m_TraceOutput &= ~WSB_TRACE_OUT_FLAGS_SET;
|
|
}
|
|
m_CommitEachEntry = commitEachEntry;
|
|
m_MaxTraceFileSize = maxTraceFileSize;
|
|
if (pTraceFileCopyName) {
|
|
m_TraceFileCopyName = pTraceFileCopyName;
|
|
m_TraceOutput &= ~WSB_TRACE_OUT_FLAGS_SET;
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::GetTraceFileControls(
|
|
OLECHAR **ppTraceFileName,
|
|
BOOL *pCommitEachEntry,
|
|
LONGLONG *pMaxTraceFileSize,
|
|
OLECHAR **ppTraceFileCopyName
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetTraceFileControls
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
if (ppTraceFileName) {
|
|
CWsbStringPtr fileName;
|
|
|
|
fileName = m_TraceFileName;
|
|
fileName.GiveTo(ppTraceFileName);
|
|
}
|
|
|
|
if (pCommitEachEntry) {
|
|
*pCommitEachEntry = m_CommitEachEntry;
|
|
}
|
|
|
|
if (pMaxTraceFileSize) {
|
|
*pMaxTraceFileSize = m_MaxTraceFileSize;
|
|
}
|
|
|
|
if (ppTraceFileCopyName) {
|
|
CWsbStringPtr fileCopyName;
|
|
|
|
fileCopyName = m_TraceFileCopyName;
|
|
fileCopyName.GiveTo(ppTraceFileCopyName);
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::Print(
|
|
OLECHAR *traceString
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::Print
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWsbStringPtr outString;
|
|
DWORD threadId;
|
|
OLECHAR tmpString[50];
|
|
|
|
try {
|
|
//
|
|
// Add the timeStamp if it is requested
|
|
//
|
|
|
|
if (m_TimeStamp) {
|
|
SYSTEMTIME stime;
|
|
|
|
GetLocalTime(&stime);
|
|
swprintf(tmpString, OLESTR("%2.02u/%2.02u %2.2u:%2.2u:%2.2u.%3.3u "),
|
|
stime.wMonth, stime.wDay,
|
|
stime.wHour, stime.wMinute,
|
|
stime.wSecond, stime.wMilliseconds);
|
|
|
|
outString.Append(tmpString);
|
|
outString.Append(" ");
|
|
}
|
|
|
|
//
|
|
// Add the trace count if requested
|
|
//
|
|
if (m_TraceCount) {
|
|
OLECHAR tmpString[50];
|
|
|
|
swprintf(tmpString, OLESTR("%8.8lX"), *(m_pTraceCountGlobal));
|
|
outString.Append(tmpString);
|
|
InterlockedIncrement(m_pTraceCountGlobal);
|
|
outString.Append(" ");
|
|
}
|
|
|
|
//
|
|
// Add the thread ID if requested
|
|
//
|
|
if (m_TraceThreadId) {
|
|
threadId = GetCurrentThreadId();
|
|
if (threadId < 0x0000FFFF) {
|
|
swprintf(tmpString, OLESTR("%4.4lX"), threadId);
|
|
} else {
|
|
swprintf(tmpString, OLESTR("%8.8lX"), threadId);
|
|
}
|
|
|
|
outString.Append(tmpString);
|
|
outString.Append(" ");
|
|
}
|
|
|
|
outString.Append(traceString);
|
|
//
|
|
// Make sure no one else writes when we do
|
|
//
|
|
Lock();
|
|
try {
|
|
if ((m_TraceOutput & WSB_TRACE_OUT_DEBUG_SCREEN) == WSB_TRACE_OUT_DEBUG_SCREEN) {
|
|
//
|
|
// Write to debug console
|
|
//
|
|
OutputDebugString(outString);
|
|
}
|
|
if ((m_TraceOutput & WSB_TRACE_OUT_STDOUT) == WSB_TRACE_OUT_STDOUT) {
|
|
//
|
|
// Write the string to the local console
|
|
//
|
|
wprintf(L"%ls", (WCHAR *) outString);
|
|
}
|
|
if ((m_TraceOutput & WSB_TRACE_OUT_FILE) == WSB_TRACE_OUT_FILE) {
|
|
//
|
|
// Make sure the file exists, etc.
|
|
//
|
|
if (m_TraceFilePointer != INVALID_HANDLE_VALUE) {
|
|
//
|
|
// Write the string to the trace file
|
|
//
|
|
WsbAffirmHr(Write(outString));
|
|
|
|
//
|
|
// See if we have used our space
|
|
//
|
|
WsbAffirmHr(WrapTraceFile());
|
|
}
|
|
}
|
|
} WsbCatch( hr );
|
|
|
|
Unlock();
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::WrapTraceFile(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::WrapTraceFile
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static BOOL stopping = FALSE;
|
|
|
|
try {
|
|
LARGE_INTEGER offset;
|
|
|
|
//
|
|
// Find out where we are writing to the file
|
|
//
|
|
offset.HighPart = 0;
|
|
offset.LowPart = SetFilePointer(m_TraceFilePointer, 0, &offset.HighPart, FILE_CURRENT);
|
|
WsbAffirm(0xFFFFFFFF != offset.LowPart || NO_ERROR == GetLastError(), E_FAIL);
|
|
|
|
//
|
|
// See if we are past the max size desired
|
|
//
|
|
if (!stopping && offset.QuadPart >= m_MaxTraceFileSize) {
|
|
|
|
// If we are doing multiple files, close this one and
|
|
// open a new one
|
|
if (m_TraceOutput & WSB_TRACE_OUT_MULTIPLE_FILES) {
|
|
|
|
// Close the current trace file
|
|
stopping = TRUE;
|
|
StopTrace();
|
|
|
|
// Increment the file count
|
|
m_TraceMultipleFileCount++;
|
|
|
|
// Create a new trace file
|
|
StartTrace();
|
|
stopping = FALSE;
|
|
|
|
// otherwise go into wrap mode
|
|
} else {
|
|
// We have gone too far so start back at the top and indicating we are wrapping.
|
|
offset.HighPart = 0;
|
|
offset.LowPart = SetFilePointer(m_TraceFilePointer, 0, &offset.HighPart, FILE_BEGIN);
|
|
WsbAffirm(0xFFFFFFFF != offset.LowPart || NO_ERROR == GetLastError(), E_FAIL);
|
|
m_WrapMode = TRUE;
|
|
}
|
|
}
|
|
|
|
if (m_WrapMode) {
|
|
// Save where we are in the file
|
|
offset.LowPart = SetFilePointer(m_TraceFilePointer, 0, &offset.HighPart, FILE_CURRENT);
|
|
WsbAffirm(0xFFFFFFFF != offset.LowPart || NO_ERROR == GetLastError(), E_FAIL);
|
|
|
|
// Write the wrap line
|
|
WsbAffirmHr(Write(OLESTR("!!! TRACE WRAPPED !!!\r\n")));
|
|
|
|
/* Go back to offset before wrap line saved */
|
|
offset.LowPart = SetFilePointer(m_TraceFilePointer, offset.LowPart,
|
|
&offset.HighPart, FILE_BEGIN);
|
|
WsbAffirm(0xFFFFFFFF != offset.LowPart || NO_ERROR == GetLastError(), E_FAIL);
|
|
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::SetOutputFormat(
|
|
BOOL timeStamp,
|
|
BOOL traceCount,
|
|
BOOL traceThreadId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetOutputFormat
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
m_TimeStamp = timeStamp;
|
|
m_TraceCount = traceCount;
|
|
m_TraceThreadId = traceThreadId;
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::GetOutputFormat(
|
|
BOOL *pTimeStamp,
|
|
BOOL *pTraceCount,
|
|
BOOL *pTraceThreadId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetOutputFormat
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
try {
|
|
WsbAffirm(0 != pTimeStamp, E_POINTER);
|
|
WsbAffirm(0 != pTraceCount, E_POINTER);
|
|
WsbAffirm(0 != pTraceThreadId, E_POINTER);
|
|
*pTimeStamp = m_TimeStamp;
|
|
*pTraceCount = m_TraceCount;
|
|
*pTraceThreadId = m_TraceThreadId;
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::GetRegistryEntry(
|
|
OLECHAR **pRegistryEntry
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetRegistryEntry
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAffirm(0 != pRegistryEntry, E_POINTER);
|
|
|
|
CWsbStringPtr entry;
|
|
entry = m_RegistrySetting;
|
|
WsbAffirmHr(entry.GiveTo(pRegistryEntry));
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::SetRegistryEntry(
|
|
OLECHAR *registryEntry
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetRegistryEntry
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_RegistrySetting = registryEntry;
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadFromRegistry(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadFromRegistry
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
if (wcslen(m_RegistrySetting) > 0) {
|
|
WsbAffirmHr(WsbEnsureRegistryKeyExists (NULL, m_RegistrySetting));
|
|
WsbAffirmHr(LoadFileSettings());
|
|
WsbAffirmHr(LoadTraceSettings());
|
|
WsbAffirmHr(LoadOutputDestinations());
|
|
WsbAffirmHr(LoadFormat());
|
|
WsbAffirmHr(LoadStart());
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadFileSettings(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadFileSettings
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
DWORD sizeGot;
|
|
OLECHAR dataString[512];
|
|
OLECHAR *stopString;
|
|
CWsbStringPtr l_TraceFileName=L"Trace";
|
|
LONGLONG l_TraceFileSize=0;
|
|
BOOL l_TraceCommit=FALSE;
|
|
CWsbStringPtr l_TraceFileCopyName;
|
|
|
|
//
|
|
// Get the values
|
|
//
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_FILE_NAME,
|
|
dataString, 512, &sizeGot);
|
|
if (hr == S_OK) {
|
|
l_TraceFileName = dataString;
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_FILE_MAX_SIZE,
|
|
dataString, 512, &sizeGot);
|
|
if (hr == S_OK) {
|
|
l_TraceFileSize = wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_FILE_COMMIT,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
if (0 == wcstoul(dataString, &stopString, 10)) {
|
|
l_TraceCommit = FALSE;
|
|
} else {
|
|
l_TraceCommit = TRUE;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_FILE_COPY_NAME,
|
|
dataString, 512, &sizeGot);
|
|
if (hr == S_OK) {
|
|
l_TraceFileCopyName = dataString;
|
|
}
|
|
|
|
hr = S_OK;
|
|
WsbAffirmHr(SetTraceFileControls(l_TraceFileName, l_TraceCommit,
|
|
l_TraceFileSize, l_TraceFileCopyName));
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadTraceSettings(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadTraceSettings
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
DWORD sizeGot;
|
|
OLECHAR dataString[100];
|
|
OLECHAR *stopString;
|
|
BOOL value = FALSE;
|
|
LONG number = 0;
|
|
LONGLONG l_TraceSettings = WSB_TRACE_BIT_NONE;
|
|
BOOL l_TraceEntryExit = TRUE;
|
|
WORD w_LogLevel = WSB_LOG_LEVEL_DEFAULT;
|
|
BOOL b_SnapShotOn = FALSE;
|
|
WORD w_SnapShotLevel = 0;
|
|
CWsbStringPtr p_SnapShotPath = L"SnapShotPath";
|
|
BOOL b_SnapShotResetTrace = FALSE;
|
|
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_PLATFORM,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_PLATFORM;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_RMS,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_RMS;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_SEG,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_SEG;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_META,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_META;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_HSMENG,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_HSMENG;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_HSMSERV,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_HSMSERV;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_JOB,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_JOB;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_HSMTSKMGR,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_HSMTSKMGR;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_FSA,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_FSA;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_DATAMIGRATER,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_DATAMIGRATER;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_DATARECALLER,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_DATARECALLER;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_DATAVERIFIER,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_DATAVERIFIER;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_UI,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_UI;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_ENTRY_EXIT,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value == FALSE) {
|
|
l_TraceEntryExit = FALSE;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_DATAMOVER,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_DATAMOVER;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_HSMCONN,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_HSMCONN;
|
|
}
|
|
}
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_IDB,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_IDB;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_COPYMEDIA,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_COPYMEDIA;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_DO_PERSISTENCE,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceSettings |= WSB_TRACE_BIT_PERSISTENCE;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_LOG_LEVEL,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
w_LogLevel = (WORD)wcstoul( dataString, &stopString, 10 ); // No conversion returns zero!
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_LOG_SNAP_SHOT_ON,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
b_SnapShotOn = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_LOG_SNAP_SHOT_LEVEL,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
w_SnapShotLevel = (WORD) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_LOG_SNAP_SHOT_PATH,
|
|
dataString, 512, &sizeGot);
|
|
if (hr == S_OK) {
|
|
p_SnapShotPath = dataString;
|
|
}
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_LOG_SNAP_SHOT_RESET_TRACE,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
b_SnapShotResetTrace = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
hr = S_OK;
|
|
WsbAffirmHr(SetTraceSettings(l_TraceSettings));
|
|
WsbAffirmHr(SetTraceEntryExit(l_TraceEntryExit));
|
|
WsbAffirmHr(SetLogLevel(w_LogLevel));
|
|
WsbAffirmHr(SetLogSnapShot(b_SnapShotOn, w_SnapShotLevel,
|
|
p_SnapShotPath, b_SnapShotResetTrace ));
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadOutputDestinations(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadOutputDestinations
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
DWORD sizeGot;
|
|
OLECHAR dataString[100];
|
|
OLECHAR *stopString;
|
|
BOOL value = FALSE;
|
|
ULONG l_TraceOutput = WSB_TRACE_OUT_NONE;
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_TO_STDOUT,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceOutput = l_TraceOutput | WSB_TRACE_OUT_STDOUT;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_TO_DEBUG,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceOutput = l_TraceOutput | WSB_TRACE_OUT_DEBUG_SCREEN;
|
|
}
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_TO_FILE,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
l_TraceOutput = l_TraceOutput | WSB_TRACE_OUT_FILE;
|
|
}
|
|
|
|
}
|
|
|
|
hr = S_OK;
|
|
WsbAffirmHr(DirectOutput(l_TraceOutput));
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadFormat(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadFormat
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
DWORD sizeGot;
|
|
OLECHAR dataString[100];
|
|
OLECHAR *stopString;
|
|
BOOL countValue = FALSE;
|
|
BOOL timeValue = FALSE;
|
|
BOOL threadValue = FALSE;
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_COUNT,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
countValue = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_TIMESTAMP,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
timeValue = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_THREADID,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
threadValue = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
}
|
|
|
|
hr = S_OK;
|
|
WsbAffirmHr(SetOutputFormat(timeValue, countValue, threadValue));
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::SetTraceEntryExit(
|
|
BOOL traceEntryExit
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetTraceEntryExit
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
g_WsbTraceEntryExit = traceEntryExit;
|
|
m_TraceEntryExit = traceEntryExit;
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
HRESULT
|
|
CWsbTrace::GetTraceEntryExit(
|
|
BOOL *pTraceEntryExit
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetTraceEntryExit
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pTraceEntryExit, E_POINTER);
|
|
*pTraceEntryExit = m_TraceEntryExit;
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::SetLogLevel(
|
|
WORD logLevel
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetLogLevel
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
g_WsbLogLevel = logLevel;
|
|
m_LogLevel = logLevel;
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::GetLogLevel(
|
|
WORD *pLogLevel
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetLogLevel
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pLogLevel, E_POINTER);
|
|
*pLogLevel = m_LogLevel;
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::SetLogSnapShot(
|
|
BOOL on,
|
|
WORD level,
|
|
OLECHAR *snapShotPath,
|
|
BOOL resetTrace
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetLogSnapShot
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
g_WsbLogSnapShotOn = on;
|
|
g_WsbLogSnapShotLevel = level;
|
|
if (snapShotPath != 0) {
|
|
wcscpy(g_pWsbLogSnapShotPath, snapShotPath);
|
|
}
|
|
g_WsbLogSnapShotResetTrace = resetTrace;
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::GetLogSnapShot(
|
|
BOOL *pOn,
|
|
WORD *pLevel,
|
|
OLECHAR **pSnapShotPath,
|
|
BOOL *pResetTrace
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::GetLogSnapShot
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pOn, E_POINTER);
|
|
WsbAssert(0 != pLevel, E_POINTER);
|
|
WsbAssert(0 != pSnapShotPath, E_POINTER);
|
|
WsbAssert(0 != pResetTrace, E_POINTER);
|
|
|
|
*pOn = g_WsbLogSnapShotOn;
|
|
|
|
CWsbStringPtr path;
|
|
path = g_pWsbLogSnapShotPath;
|
|
path.GiveTo(pSnapShotPath);
|
|
|
|
*pLevel = g_WsbLogSnapShotLevel;
|
|
*pResetTrace = g_WsbLogSnapShotResetTrace;
|
|
|
|
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::LoadStart(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::LoadStart
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
DWORD sizeGot;
|
|
OLECHAR dataString[100];
|
|
OLECHAR *stopString;
|
|
BOOL value = FALSE;
|
|
|
|
hr = WsbGetRegistryValueString(NULL, m_RegistrySetting, WSB_TRACE_ON,
|
|
dataString, 100, &sizeGot);
|
|
if (hr == S_OK) {
|
|
value = (BOOL) wcstoul( dataString, &stopString, 10 );
|
|
if (value) {
|
|
StartTrace();
|
|
} else {
|
|
StopTrace();
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
} WsbCatch( hr );
|
|
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
// Write - write a WCHAR string to the output file as multibyte chars.
|
|
HRESULT
|
|
CWsbTrace::Write(
|
|
OLECHAR *pString
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
const int safe_size = 1024;
|
|
static char buf[safe_size + 16];
|
|
|
|
try {
|
|
int nbytes;
|
|
int nchars_todo;
|
|
int nchars_remaining;
|
|
OLECHAR *pSource;
|
|
OLECHAR *pTest;
|
|
BOOL needToAddReturn = FALSE;
|
|
CWsbStringPtr endOfLine("\r\n");
|
|
|
|
// Get the total number of chars. in the string
|
|
pSource = pString;
|
|
nchars_remaining = wcslen(pSource);
|
|
pTest = (pString + nchars_remaining - 1);
|
|
//
|
|
// Make sure that if this is a terminating line
|
|
// that it is a \r\n termination not just a
|
|
// \n.
|
|
//
|
|
if (*pTest == '\n') {
|
|
pTest--;
|
|
if (*pTest != '\r') {
|
|
needToAddReturn = TRUE;
|
|
nchars_remaining--;
|
|
}
|
|
}
|
|
|
|
// Loop until all chars. are written
|
|
while (nchars_remaining) {
|
|
DWORD bytesWritten;
|
|
|
|
if (nchars_remaining * sizeof(OLECHAR) > safe_size) {
|
|
nchars_todo = safe_size / sizeof(OLECHAR);
|
|
} else {
|
|
nchars_todo = nchars_remaining;
|
|
}
|
|
|
|
// Convert characters from wide to narrow
|
|
do {
|
|
nbytes = wcstombs(buf, pSource, nchars_todo);
|
|
if (nbytes <= 0) {
|
|
|
|
// Hit a bad character; try fewer characters
|
|
nchars_todo /= 2;
|
|
if (0 == nchars_todo) {
|
|
|
|
// Skip the next character
|
|
nchars_todo = 1;
|
|
nbytes = 1;
|
|
buf[0] = '?';
|
|
}
|
|
}
|
|
} while (nbytes <= 0);
|
|
|
|
WsbAffirm(WriteFile(m_TraceFilePointer, buf, nbytes,
|
|
&bytesWritten, NULL), E_FAIL);
|
|
WsbAffirm(static_cast<int>(bytesWritten) == nbytes, E_FAIL);
|
|
nchars_remaining -= nchars_todo;
|
|
pSource += nchars_todo;
|
|
}
|
|
|
|
if (needToAddReturn) {
|
|
DWORD bytesWritten;
|
|
|
|
nbytes = wcstombs(buf, (OLECHAR *)endOfLine, 2);
|
|
WsbAffirm(nbytes > 0, E_FAIL);
|
|
WsbAffirm(WriteFile(m_TraceFilePointer, buf, nbytes,
|
|
&bytesWritten, NULL), E_FAIL);
|
|
WsbAffirm(static_cast<int>(bytesWritten) == nbytes, E_FAIL);
|
|
|
|
}
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbTrace::SetTraceSettings(
|
|
LONGLONG traceElements
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTrace::SetTraceSettings
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try
|
|
{
|
|
|
|
g_WsbTraceModules = traceElements;
|
|
m_TraceSettings = g_WsbTraceModules;
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return( hr );
|
|
}
|