Leaked source code of windows server 2003
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.
 
 
 
 
 
 

863 lines
24 KiB

//+---------------------------------------------------------------------------
// Copyright (C) 1991, Microsoft Corporation.
//
// File: assert.cxx
//
// Contents: Debugging output routines for idsmgr.dll
//
// Functions: Assert
// PopUpError
//
// History: 23-Jul-91 KyleP Created.
// 09-Oct-91 KevinRo Major changes and comments added
// 18-Oct-91 vich moved debug print routines out
// 10-Jun-92 BryanT Switched to w4crt.h instead of wchar.h
// 30-Sep-93 KyleP DEVL obsolete
//
//----------------------------------------------------------------------------
#pragma hdrstop
//
// This one file **always** uses debugging options
//
#if DBG == 1
#include <stdarg.h>
#include <stdio.h>
#include <dprintf.h> // w4printf, w4dprintf prototypes
#include <debnot.h>
#include <olesem.hxx>
#include <windows.h>
#include <netevent.h>
#include <stackwalk.h>
#include <asrtcfg.h>
#include <privguid.h>
#include <memapi.hxx>
unsigned long Win4InfoLevel = DEF_INFOLEVEL;
unsigned long Win4InfoMask = 0xffffffff;
BOOL gAssertOnCreate = TRUE;
int ForceAV();
//+---------------------------------------------------------------------------
//
// Function: _asdprintf
//
// Synopsis: Calls vdprintf to output a formatted message.
//
// History: 18-Oct-91 vich Created
//
//----------------------------------------------------------------------------
inline void __cdecl
_asdprintf(
char const *pszfmt, ...)
{
va_list va;
va_start(va, pszfmt);
vdprintf(DEB_FORCE, "Assert", pszfmt, va);
va_end(va);
}
typedef enum
{
ASSRTCFG_BREAK = 0x01,
ASSRTCFG_POPUP = 0x02,
ASSRTCFG_DEBUGMESSAGE = 0x04,
ASSRTCFG_PRINTSTACK = 0x08,
ASSRTCFG_USEAV = 0x10
} ASSRTCFG;
//+---------------------------------------------------------------------
//
// Class: CAssertInfo
//
// Synopsis: Data type to trake assertion and logging parameters
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------
class CAssertInfo : public IAssertConfig
{
public:
CAssertInfo() : _dwFlags(ASSRTCFG_POPUP | ASSRTCFG_DEBUGMESSAGE) {}
//
// IUnknown
//
STDMETHOD(QueryInterface)(REFIID riid, PVOID * ppv)
{
if ((IsEqualIID(riid, IID_IUnknown)) ||
(IsEqualIID(riid, IID_IAssertConfig)))
{
*ppv = this;
AddRef();
return S_OK;
}
else
{
return E_NOINTERFACE;
}
}
STDMETHOD_(ULONG, AddRef)() { return 1;}
STDMETHOD_(ULONG, Release)() { return 1;}
//
// IConfigAssert
//
STDMETHOD(SetBreak)(BOOL f) { SetFlag(f, ASSRTCFG_BREAK); return S_OK;}
STDMETHOD(SetPopup)(BOOL f) { SetFlag(f, ASSRTCFG_POPUP); return S_OK;}
STDMETHOD(SetDebuggerMessage)(BOOL f) { SetFlag(f, ASSRTCFG_DEBUGMESSAGE); return S_OK;}
STDMETHOD(SetPrintStack)(BOOL f) { SetFlag(f, ASSRTCFG_PRINTSTACK); return S_OK;}
STDMETHOD(SetUseAV)(BOOL f) { SetFlag(f, ASSRTCFG_USEAV); return S_OK;}
STDMETHOD(SetLog)(ASSRTLOGINFO *pLogInfo) { _logInfo = *pLogInfo; return S_OK;}
STDMETHOD(SetContextString)(char *psz){ _pszContext = psz; return S_OK;}
STDMETHOD(SetThreshold)(ULONG cTh) { _cThreshold = cTh; return S_OK;}
//
// helpers
//
void Win4AssertEx(char const * szFile, int iLine, char const * szMessage);
int PopUpError(char const *szMsg, int iLine, char const *szFile);
void ComposeErrorMessage(char const *szMsg, int iLine, char const *szFile);
void AppendToFile(char *pszFileName, char const *pwszData);
void FatalErrorHandler(char *errmsg);
void LogAssertionFailure(char const * szMessage);
private:
void SetFlag(BOOL f, DWORD bit)
{
_dwFlags = f ? _dwFlags | bit : _dwFlags & ~bit;
}
char *GetStack();
BOOL GetBreak() {return _dwFlags | ASSRTCFG_BREAK;}
BOOL GetPopup() {return _dwFlags | ASSRTCFG_POPUP;}
BOOL GetDebugMessage() {return _dwFlags | ASSRTCFG_DEBUGMESSAGE;}
void BreakIntoDebugger()
{
if (_dwFlags & ASSRTCFG_USEAV)
ForceAV();
else
DebugBreak();
}
DWORD _dwFlags; // what to do when an assertion fails
ASSRTLOGINFO _logInfo; // if/where to write a log entry
char *_pszContext; // user supplied context string for the log
char _errMessage[128]; // generated error string
ULONG _cThreshold; // number of assertion to ignore
ULONG _cAssrtFail; // number of assertion failures so far
};
CAssertInfo gAssertInfo;
//+---------------------------------------------------------------------------
//
// Method: Win4AssertEx
//
// Synopsis: Called on assertion failure. Takes appropriate action based
// on member variables
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void CAssertInfo::Win4AssertEx(
char const * szFile,
int iLine,
char const * szMessage)
{
_cAssrtFail++;
if (_cAssrtFail < _cThreshold)
{
return;
}
ComposeErrorMessage(szMessage, iLine, szFile);
BOOL fBrokeAlready = FALSE;
if (_dwFlags & ASSRTCFG_DEBUGMESSAGE)
{
DWORD tid = GetCurrentThreadId();
_asdprintf("%s\n%s\n", _errMessage, szMessage);
}
if (_logInfo.dwDest & ASSRTLOG_FILE)
{
AppendToFile(_logInfo.pszFileName, szMessage);
}
if (_logInfo.dwDest & ASSRTLOG_NTEVENTLOG)
{
LogAssertionFailure(szMessage);
}
if (_dwFlags & ASSRTCFG_POPUP)
{
int id = PopUpError(szMessage, iLine, szFile);
if (id == IDCANCEL)
{
fBrokeAlready = TRUE;
BreakIntoDebugger();
}
}
if ((_dwFlags & ASSRTCFG_BREAK) && !fBrokeAlready)
{
BreakIntoDebugger();
}
}
//+------------------------------------------------------------
// Method: PopUpError
//
// Synopsis: Displays a dialog box using provided text,
// and presents the user with the option to
// continue or cancel.
//
// Arguments:
// szMsg -- The string to display in main body of dialog
// iLine -- Line number of file in error
// szFile -- Filename of file in error
//
// Returns:
// IDCANCEL -- User selected the CANCEL button
// IDOK -- User selected the OK button
//-------------------------------------------------------------
int CAssertInfo::PopUpError(char const *szMsg, int iLine, char const *szFile)
{
int id;
WCHAR wszWinsta[64];
HWINSTA hWinsta;
DWORD Size;
DWORD dwMessageFlags = MB_SETFOREGROUND | MB_TASKMODAL |
MB_ICONEXCLAMATION | MB_OKCANCEL;
hWinsta = GetProcessWindowStation();
Size = sizeof(wszWinsta);
wszWinsta[0] = 0;
if ( hWinsta )
{
(void) GetUserObjectInformation(
hWinsta,
UOI_NAME,
wszWinsta,
Size,
&Size );
}
//
// This makes popups from non-interactive servers/services (including
// rpcss) visible.
//
if ( wszWinsta[0] && (lstrcmpiW(wszWinsta,L"Winsta0") != 0) )
dwMessageFlags |= MB_SERVICE_NOTIFICATION | MB_DEFAULT_DESKTOP_ONLY;
id = MessageBoxA(NULL,(char *) szMsg, (LPSTR) _errMessage,
dwMessageFlags);
// If id == 0, then an error occurred. There are two possibilities
// that can cause the error: Access Denied, which means that this
// process does not have access to the default desktop, and everything
// else (usually out of memory). Oh well.
return id;
}
//+---------------------------------------------------------------------------
//
// Method: ComposeErrorMessage
//
// Synopsis: Put together a message that contains useful info about the
// context of the error
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void CAssertInfo::ComposeErrorMessage(
char const *szMsg,
int iLine,
char const *szFile)
{
static char szModuleName[128];
DWORD tid = GetCurrentThreadId();
DWORD pid = GetCurrentProcessId();
char * pszModuleName;
BOOL bStatus;
if (GetModuleFileNameA(NULL, szModuleName, 128))
{
pszModuleName = strrchr(szModuleName, '\\');
if (!pszModuleName)
{
pszModuleName = szModuleName;
}
else
{
pszModuleName++;
}
}
else
{
pszModuleName = "Unknown";
}
wsprintfA(_errMessage,"Process: %s File: %s line %u, thread id %d.%d",
pszModuleName, szFile, iLine, pid, tid);
}
//+---------------------------------------------------------------------------
//
// Method: AppendToFile
//
// Synopsis: Write assertion failures to a log file.
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void CAssertInfo::AppendToFile(char *pszFileName, char const *pwszData)
{
HANDLE hFile = CreateFileA(pszFileName,
GENERIC_WRITE,
0,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
FatalErrorHandler("Could not open log File.");
}
DWORD ret = SetFilePointer(hFile, 0, 0, FILE_END);
if (ret == -1)
{
FatalErrorHandler("Could not set file pointer.");
}
DWORD dwBytesWritten;
BOOL ok = WriteFile(hFile, _errMessage,
lstrlenA(_errMessage),
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
ok = WriteFile(hFile, "\n", 1,
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
ok = WriteFile(hFile, pwszData,
lstrlenA(pwszData),
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
ok = WriteFile(hFile, "\n", 1,
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
if (_dwFlags & ASSRTCFG_PRINTSTACK)
{
char *psz = GetStack();
if (psz)
{
ok = WriteFile(hFile, psz,
lstrlenA(psz),
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
PrivMemFree(psz);
}
}
if (_pszContext)
{
ok = WriteFile(hFile, pwszData,
lstrlenA(pwszData),
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
ok = WriteFile(hFile, "\n", 1,
&dwBytesWritten, NULL);
if (!ok)
{
FatalErrorHandler("Could not write to log File.");
}
}
CloseHandle(hFile);
}
//+---------------------------------------------------------------------------
//
// Function: GetStackExceptionFilter
//
// Synopsis: Walk stack and store in a string variable
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
extern HRESULT CStackWalkerCF_CreateInstance (IUnknown *pUnkOuter, REFIID riid, void** ppv);
LONG GetStackExceptionFilter(LPEXCEPTION_POINTERS lpep, char **ppStack)
{
HRESULT hr;
LONG lRet = EXCEPTION_EXECUTE_HANDLER;
IStackWalker* pIStackWalker = NULL;
IStackWalkerStack* pIStack = NULL;
*ppStack = NULL;
DWORD dwFault = lpep->ExceptionRecord->ExceptionCode;
if (dwFault != 0xceadbeef)
{
lRet = EXCEPTION_CONTINUE_SEARCH;
goto Cleanup;
}
hr = CStackWalkerCF_CreateInstance (NULL, IID_IStackWalker, (void**) &pIStackWalker);
if (FAILED (hr))
goto Cleanup;
hr = pIStackWalker->Attach (NULL);
if (FAILED (hr))
goto Cleanup;
pIStack = pIStackWalker->CreateStackTrace (lpep->ContextRecord, NULL, 0);
if (!pIStack)
goto Cleanup;
SIZE_T nLen = pIStack->Size (20);
WCHAR * szStack = new WCHAR[nLen];
if (szStack)
{
if (pIStack->GetStack (nLen, szStack, 20))
{
*ppStack = (char *) PrivMemAlloc(nLen);
if (*ppStack)
{
wcstombs(*ppStack, szStack, lstrlenW(szStack));
}
}
delete [] szStack;
}
Cleanup:
if (pIStackWalker)
pIStackWalker->Release();
if (pIStack)
pIStack->Release();
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: GetStack
//
// Synopsis: Throws and exception so the filter can get stack info
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
char *CAssertInfo::GetStack()
{
char *pStack = NULL;
__try
{
RaiseException(0xceadbeef, 0, 0, NULL);
}
__except(GetStackExceptionFilter(GetExceptionInformation(), &pStack))
{
}
return pStack;
}
//+---------------------------------------------------------------------------
//
// Method: FatalErrorHandler
//
// Synopsis: Called when the assertion code itself cannot allocate
// enough resources to log the assertion failure.
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void CAssertInfo::FatalErrorHandler(char *szMessage)
{
BOOL fBrokeAlready = FALSE;
lstrcpyA(_errMessage, "Fatal error while processing assertion failure");
_asdprintf("%s\n%s\n", _errMessage, szMessage);
if (_dwFlags & ASSRTCFG_POPUP)
{
int id = PopUpError(szMessage, __LINE__, __FILE__);
if (id == IDCANCEL)
{
fBrokeAlready = TRUE;
BreakIntoDebugger();
}
}
if (_dwFlags & ASSRTCFG_BREAK && !fBrokeAlready)
{
BreakIntoDebugger();
}
}
//+---------------------------------------------------------------------------
//
// Method: LogAssertionFailure
//
// Synopsis: Write and assertion failure to the NT event log
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void CAssertInfo::LogAssertionFailure(char const * szMessage)
{
HANDLE LogHandle;
char const * Strings[3]; // array of message strings.
Strings[0] = _errMessage;
Strings[1] = szMessage;
Strings[2] = _pszContext ? _pszContext : "";
// Get the log handle, then report the event.
LogHandle = RegisterEventSource( NULL, L"DCOM" );
if ( LogHandle )
{
ReportEventA( LogHandle,
EVENTLOG_ERROR_TYPE,
0, // event category
EVENT_DCOM_ASSERTION_FAILURE,
NULL,
3, // 3 strings passed
0, // 0 bytes of binary
Strings, // array of strings
NULL ); // no raw data
// clean up the event log handle
DeregisterEventSource(LogHandle);
}
else
{
FatalErrorHandler("Could not register as event source");
}
}
//+------------------------------------------------------------
// Function: vdprintf
//
// Synopsis: Prints debug output using a pointer to the
// variable information. Used primarily by the
// xxDebugOut macros
//
// Arguements:
// ulCompMask -- Component level mask used to determine
// output ability
// pszComp -- String const of component prefix.
// ppszfmt -- Pointer to output format and data
//
//-------------------------------------------------------------
//
// This semaphore is *outside* vdprintf because the compiler isn't smart
// enough to serialize access for construction if it's function-local and
// protected by a guard variable.
//
// KyleP - 20 May, 1993
//
COleStaticMutexSem g_mxsVdprintf;
BOOL g_mxsVdprintfInitialized = TRUE;
STDAPI_(void) vdprintf(
unsigned long ulCompMask,
char const *pszComp,
char const *ppszfmt,
va_list pargs)
{
if ((ulCompMask & DEB_FORCE) == DEB_FORCE ||
((ulCompMask | Win4InfoLevel) & Win4InfoMask))
{
if ((Win4InfoLevel & (DEB_DBGOUT | DEB_STDOUT)) != DEB_STDOUT)
{
if (! (ulCompMask & DEB_NOCOMPNAME))
{
DWORD tid = GetCurrentThreadId();
DWORD pid = GetCurrentProcessId();
if (g_mxsVdprintfInitialized)
LOCK (g_mxsVdprintf);
w4dprintf( "%d.%03dp> ", pid, tid );
w4dprintf("%s: ", pszComp);
w4vdprintf(ppszfmt, pargs);
if (g_mxsVdprintfInitialized)
UNLOCK (g_mxsVdprintf);
}
}
}
}
//+---------------------------------------------------------------------------
//
// Function: ForceAV
//
// Synopsis: Cause and Access Violation
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
int ForceAV()
{
return *((int *) 0);
}
//+---------------------------------------------------------------------------
//
// Function: _Win4Assert, private
//
// Synopsis: Display assertion information
//
// Effects: Called when an assertion is hit.
//
// History: 12-Jul-91 AlexT Created.
// 05-Sep-91 AlexT Catch Throws and Catches
// 19-Oct-92 HoiV Added events for TOM
//
//----------------------------------------------------------------------------
STDAPI_(void) Win4AssertEx(
char const * szFile,
int iLine,
char const * szMessage)
{
gAssertInfo.Win4AssertEx(szFile, iLine, szMessage);
}
//+------------------------------------------------------------
// Function: SetWin4InfoLevel(unsigned long ulNewLevel)
//
// Synopsis: Sets the global info level for debugging output
// Returns: Old info level
//
//-------------------------------------------------------------
EXPORTIMP unsigned long APINOT
SetWin4InfoLevel(
unsigned long ulNewLevel)
{
unsigned long ul;
ul = Win4InfoLevel;
Win4InfoLevel = ulNewLevel;
return(ul);
}
//+------------------------------------------------------------
// Function: _SetWin4InfoMask(unsigned long ulNewMask)
//
// Synopsis: Sets the global info mask for debugging output
// Returns: Old info mask
//
//-------------------------------------------------------------
EXPORTIMP unsigned long APINOT
SetWin4InfoMask(
unsigned long ulNewMask)
{
unsigned long ul;
ul = Win4InfoMask;
Win4InfoMask = ulNewMask;
return(ul);
}
//+---------------------------------------------------------------------------
//
// Function: ReadINIFile
//
// Synopsis: Get a paremeter value from the win.ini file
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
BOOL ReadINIFile(char * pszKey, BOOL * pVal)
{
static char szValue[128];
if (GetProfileStringA("CairOLE Assertions", // section
pszKey, // key
"", // default value
szValue, // return buffer
128))
{
*pVal = (lstrcmpiA(szValue, "yes") == 0) ;
return TRUE;
}
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Function: AssertDebugInit
//
// Synopsis: Initialize the assertion data structure using the win.ini file
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
void AssertDebugInit()
{
#define ASSERT_SET(key) \
{ \
BOOL val; \
if (ReadINIFile(#key, &val)) \
{ \
gAssertInfo.Set##key(val); \
} \
} \
static char szValue[128];
ASSERT_SET(Break);
ASSERT_SET(Popup);
ASSERT_SET(DebuggerMessage);
ASSERT_SET(PrintStack);
ASSERT_SET(UseAV);
ASSRTLOGINFO logInfo;
memset(&logInfo, 0, sizeof(logInfo));
if (GetProfileStringA("CairOLE Assertions", // section
"Log_File", // key
"", // default value
logInfo.pszFileName, // return buffer
MAX_PATH))
{
if (lstrcmpA("", logInfo.pszFileName) != 0)
{
logInfo.dwDest |= ASSRTLOG_FILE;
}
}
if (GetProfileStringA("CairOLE Assertions", // section
"Log_NtEventLog", // key
"", // default value
szValue, // return buffer
128))
{
logInfo.dwDest |= (lstrcmpiA(szValue, "yes") == 0 )? ASSRTLOG_NTEVENTLOG : 0;
}
if (logInfo.dwDest)
{
gAssertInfo.SetLog(&logInfo);
}
if (GetProfileStringA("CairOLE Assertions", // section
"AssertOnCreate", // key
"", // default value
szValue, // return buffer
128))
{
gAssertOnCreate = FALSE;
}
}
//+---------------------------------------------------------------------------
//
// Function: CoGetAssertConfig
//
// Synopsis: CI for CAssertInfo. gAssertInfo is a singleton,
// so just to a QI
//
// History: 27-Jan-99 MattSmit Created
//
//----------------------------------------------------------------------------
HRESULT CoGetAssertConfig(REFIID riid, PVOID *ppv)
{
return gAssertInfo.QueryInterface(riid, ppv);
}
#else
int assertDontUseThisName(void)
{
return 1;
}
#endif // DBG == 1