// --------------------------------------------------------------------------
// Module Name: StandardDebug.cpp
//
// Copyright (c) 1999-2000, Microsoft Corporation
//
// This file defines standard debug helper functions for winlogon/GINA
// projects for neptune.
//
// History: 1999-09-10 vtan created
// 2000-01-31 vtan moved from Neptune to Whistler
// --------------------------------------------------------------------------
#include "StandardHeader.h"
#include <stdio.h>
#ifdef DBG
// --------------------------------------------------------------------------
// gLastResult
//
// Purpose: Temporary global that stores the last result.
// --------------------------------------------------------------------------
LONG gLastResult = ERROR_SUCCESS;
// --------------------------------------------------------------------------
// CDebug::sHasUserModeDebugger
// CDebug::sHasKernelModeDebugger
//
// Purpose: Booleans that indicate debugger status on this machine for
// Winlogon. ntdll!DebugBreak should only be invoked if either
// debugger is present (ntsd piped to kd).
// --------------------------------------------------------------------------
bool CDebug::s_fHasUserModeDebugger = false;
bool CDebug::s_fHasKernelModeDebugger = false;
// --------------------------------------------------------------------------
// CDebug::AttachUserModeDebugger
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Attaches a user mode debugger to the current process. Useful
// if you can't start the process under a debugger but still
// want to be able to debug the process.
//
// History: 2000-11-04 vtan created
// --------------------------------------------------------------------------
void CDebug::AttachUserModeDebugger (void)
{
HANDLE hEvent;
STARTUPINFO startupInfo;
PROCESS_INFORMATION processInformation;
SECURITY_ATTRIBUTES sa;
TCHAR szCommandLine[MAX_PATH];
ZeroMemory(&startupInfo, sizeof(startupInfo));
ZeroMemory(&processInformation, sizeof(processInformation));
startupInfo.cb = sizeof(startupInfo);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
hEvent = CreateEvent(&sa, TRUE, FALSE, NULL);
wsprintf(szCommandLine, TEXT("ntsd -dgGx -p %ld -e %ld"), GetCurrentProcessId(), hEvent);
if (CreateProcess(NULL,
szCommandLine,
NULL,
NULL,
TRUE,
0,
NULL,
NULL,
&startupInfo,
&processInformation) != FALSE)
{
TBOOL(CloseHandle(processInformation.hThread));
TBOOL(CloseHandle(processInformation.hProcess));
(DWORD)WaitForSingleObject(hEvent, 10 * 1000);
}
TBOOL(CloseHandle(hEvent));
}
// --------------------------------------------------------------------------
// CDebug::Break
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Breaks into the debugger if the hosting process has been
// started with a debugger and kernel debugger is present.
//
// History: 2000-09-11 vtan created
// --------------------------------------------------------------------------
void CDebug::Break (void)
{
if (s_fHasUserModeDebugger || s_fHasKernelModeDebugger)
{
DebugBreak();
}
}
// --------------------------------------------------------------------------
// CDebug::BreakIfRequested
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: If breakins are requested then breaks into the debugger if
// present.
//
// This function explicitly uses Win32 Registry APIs to avoid
// link dependencies on debug code with library code.
//
// History: 1999-09-13 vtan created
// 1999-11-16 vtan removed library code dependency
// 2001-02-21 vtan breaks have teeth
// --------------------------------------------------------------------------
void CDebug::BreakIfRequested (void)
{
#if 0
Break();
#else
HKEY hKeySettings;
// Keep retrieving this value form the registry so that it
// can be altered without restarting the machine.
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"),
0,
KEY_READ,
&hKeySettings))
{
DWORD dwBreakFlags, dwBreakFlagsSize;
dwBreakFlagsSize = sizeof(dwBreakFlags);
if ((ERROR_SUCCESS == RegQueryValueEx(hKeySettings,
TEXT("BreakFlags"),
NULL,
NULL,
reinterpret_cast<LPBYTE>(&dwBreakFlags),
&dwBreakFlagsSize)) &&
((dwBreakFlags & FLAG_BREAK_ON_ERROR) != 0))
{
Break();
}
TW32(RegCloseKey(hKeySettings));
}
#endif
}
// --------------------------------------------------------------------------
// CDebug::DisplayStandardPrefix
//
// Arguments: <none>
//
// Returns: <none>
//
// Purpose: Displays the standard prefix before any debug spew to help
// identify the source.
//
// History: 1999-10-14 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplayStandardPrefix (void)
{
TCHAR szModuleName[MAX_PATH];
if (GetModuleFileName(NULL, szModuleName, ARRAYSIZE(szModuleName)) != 0)
{
TCHAR *pTC;
pTC = szModuleName + lstrlen(szModuleName) - 1;
while ((pTC >= szModuleName) && (*pTC != TEXT('\\')))
{
--pTC;
}
if (*pTC == TEXT('\\'))
{
++pTC;
}
OutputDebugString(pTC);
}
else
{
OutputDebugString(TEXT("UNKNOWN IMAGE"));
}
OutputDebugStringA(": ");
}
// --------------------------------------------------------------------------
// CDebug::DisplayError
//
// Arguments: eType = Type of error that occurred. This
// determines what string is used.
// code = Error code that occurred or zero if N/A.
// pszFunction = Function that was invoked.
// pszSource = Source file error occurred in.
// iLine = Line number within the source file.
//
// Returns: <none>
//
// Purpose: Displays an error message specific the type of error that
// occurred.
//
// History: 1999-09-13 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplayError (TRACE_ERROR_TYPE eType, LONG code, const char *pszFunction, const char *pszSource, int iLine)
{
LONG lastError;
char szOutput[1024];
switch (eType)
{
case TRACE_ERROR_TYPE_WIN32:
{
lastError = code;
sprintf(szOutput, "Unexpected Win32 (%d) for %s in %s at line %d\r\n", lastError, pszFunction, pszSource, iLine);
break;
}
case TRACE_ERROR_TYPE_BOOL:
{
lastError = GetLastError();
sprintf(szOutput, "Unexpected BOOL (GLE=%d) for %s in %s at line %d\r\n", lastError, pszFunction, pszSource, iLine);
break;
}
case TRACE_ERROR_TYPE_HRESULT:
{
lastError = GetLastError();
sprintf(szOutput, "Unexpected HRESULT (%08x:GLE=%d) for %s in %s at line %d\r\n", code, lastError, pszFunction, pszSource, iLine);
break;
}
case TRACE_ERROR_TYPE_NTSTATUS:
{
const char *pszType;
if (NT_ERROR(code))
{
pszType = "NT_ERROR";
}
else if (NT_WARNING(code))
{
pszType = "NT_WARNING";
}
else if (NT_INFORMATION(code))
{
pszType = "NT_INFORMATION";
}
else
{
pszType = "UNKNOWN";
}
sprintf(szOutput, "%s (%08x) for %s in %s at line %d\r\n", pszType, code, pszFunction, pszSource, iLine);
break;
}
default:
{
lstrcpyA(szOutput, "\r\n");
}
}
DisplayStandardPrefix();
OutputDebugStringA(szOutput);
BreakIfRequested();
}
// --------------------------------------------------------------------------
// CDebug::DisplayMessage
//
// Arguments: pszMessage = Message to display.
//
// Returns: <none>
//
// Purpose: Displays the message - no break.
//
// History: 2000-12-05 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplayMessage (const char *pszMessage)
{
DisplayStandardPrefix();
OutputDebugStringA(pszMessage);
OutputDebugStringA("\r\n");
}
// --------------------------------------------------------------------------
// CDebug::DisplayAssert
//
// Arguments: pszMessage = Message to display in assertion failure.
// fForceBreak = Forces break into debugger if present.
//
// Returns: <none>
//
// Purpose: Displays the assertion failure message and breaks into the
// debugger if requested.
//
// History: 1999-09-13 vtan created
// 2000-09-11 vtan add force break
// --------------------------------------------------------------------------
void CDebug::DisplayAssert (const char *pszMessage, bool fForceBreak)
{
DisplayMessage(pszMessage);
if (fForceBreak)
{
Break();
}
else
{
BreakIfRequested();
}
}
// --------------------------------------------------------------------------
// CDebug::DisplayWarning
//
// Arguments: pszMessage = Message to display as a warning.
//
// Returns: <none>
//
// Purpose: Displays the warning message.
//
// History: 1999-09-13 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplayWarning (const char *pszMessage)
{
DisplayStandardPrefix();
OutputDebugStringA("WARNING: ");
OutputDebugStringA(pszMessage);
OutputDebugStringA("\r\n");
}
// --------------------------------------------------------------------------
// CDebug::DisplayDACL
//
// Arguments: hObject = HANDLE to object to display DACL of.
// seObjectType = Object type.
//
// Returns: <none>
//
// Purpose: Displays the discretionary access control list of the object
// using the kernel debugger.
//
// History: 1999-10-15 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplayDACL (HANDLE hObject, SE_OBJECT_TYPE seObjectType)
{
PACL pDACL;
PSECURITY_DESCRIPTOR pSD;
DisplayStandardPrefix();
OutputDebugStringA("Display DACL\r\n");
pSD = NULL;
pDACL = NULL;
if (ERROR_SUCCESS == GetSecurityInfo(hObject,
seObjectType,
DACL_SECURITY_INFORMATION,
NULL,
NULL,
&pDACL,
NULL,
&pSD))
{
int i, iLimit;
unsigned char *pUC;
pUC = reinterpret_cast<unsigned char*>(pDACL + 1);
iLimit = pDACL->AceCount;
for (i = 0; i < iLimit; ++i)
{
ACE_HEADER *pAceHeader;
char aszString[256];
wsprintfA(aszString, "ACE #%d/%d:\r\n", i + 1, iLimit);
OutputDebugStringA(aszString);
pAceHeader = reinterpret_cast<ACE_HEADER*>(pUC);
switch (pAceHeader->AceType)
{
case ACCESS_ALLOWED_ACE_TYPE:
{
ACCESS_ALLOWED_ACE *pAce;
OutputDebugStringA("\tAccess ALLOWED ACE");
pAce = reinterpret_cast<ACCESS_ALLOWED_ACE*>(pAceHeader);
OutputDebugStringA("\t\tSID = ");
DisplaySID(reinterpret_cast<PSID>(&pAce->SidStart));
wsprintfA(aszString, "\t\tMask = %08x\r\n", pAce->Mask);
OutputDebugStringA(aszString);
wsprintfA(aszString, "\t\tFlags = %08x\r\n", pAce->Header.AceFlags);
OutputDebugStringA(aszString);
break;
}
case ACCESS_DENIED_ACE_TYPE:
{
ACCESS_DENIED_ACE *pAce;
OutputDebugStringA("\tAccess DENIED ACE");
pAce = reinterpret_cast<ACCESS_DENIED_ACE*>(pAceHeader);
OutputDebugStringA("\t\tSID = ");
DisplaySID(reinterpret_cast<PSID>(&pAce->SidStart));
wsprintfA(aszString, "\t\tMask = %08x\r\n", pAce->Mask);
OutputDebugStringA(aszString);
wsprintfA(aszString, "\t\tFlags = %08x\r\n", pAce->Header.AceFlags);
OutputDebugStringA(aszString);
break;
}
default:
OutputDebugStringA("\tOther ACE type\r\n");
break;
}
pUC += pAceHeader->AceSize;
}
ReleaseMemory(pSD);
}
}
// --------------------------------------------------------------------------
// CDebug::StaticInitialize
//
// Arguments: <none>
//
// Returns: NTSTATUS
//
// Purpose: Establishes the presence of the kernel debugger or if the
// current process is being debugged.
//
// History: 1999-09-13 vtan created
// --------------------------------------------------------------------------
NTSTATUS CDebug::StaticInitialize (void)
{
NTSTATUS status;
HANDLE hDebugPort;
SYSTEM_KERNEL_DEBUGGER_INFORMATION kdInfo;
status = NtQuerySystemInformation(SystemKernelDebuggerInformation, &kdInfo, sizeof(kdInfo), NULL);
if (NT_SUCCESS(status))
{
s_fHasKernelModeDebugger = (kdInfo.KernelDebuggerEnabled != FALSE);
status = NtQueryInformationProcess(NtCurrentProcess(), ProcessDebugPort, reinterpret_cast<PVOID>(&hDebugPort), sizeof(hDebugPort), NULL);
if (NT_SUCCESS(status))
{
s_fHasUserModeDebugger = (hDebugPort != NULL);
}
}
return(status);
}
// --------------------------------------------------------------------------
// CDebug::StaticTerminate
//
// Arguments: <none>
//
// Returns: NTSTATUS
//
// Purpose: Does nothing but should clean up allocated resources.
//
// History: 1999-09-13 vtan created
// --------------------------------------------------------------------------
NTSTATUS CDebug::StaticTerminate (void)
{
return(STATUS_SUCCESS);
}
// --------------------------------------------------------------------------
// CDebug::DisplaySID
//
// Arguments: pSID = SID to display as a string.
//
// Returns: <none>
//
// Purpose: Converts the given SID to a string and displays it.
//
// History: 1999-10-15 vtan created
// --------------------------------------------------------------------------
void CDebug::DisplaySID (PSID pSID)
{
UNICODE_STRING sidString;
RtlInitUnicodeString(&sidString, NULL);
TSTATUS(RtlConvertSidToUnicodeString(&sidString, pSID, TRUE));
sidString.Buffer[sidString.Length / sizeof(WCHAR)] = L'\0';
OutputDebugStringW(sidString.Buffer);
OutputDebugStringA("\r\n");
RtlFreeUnicodeString(&sidString);
}
#endif /* DBG */