able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/pchealth/client/faultrep/fruser.cpp

1871 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************************************************************
Copyright (c) 2000 Microsoft Corporation
Module Name:
fruser.cpp
Abstract:
Implements user fault reporting for unhandled exceptions
Revision History:
created derekm 07/07/00
******************************************************************************/
#include "stdafx.h"
#include "dbghelp.h"
#include "wtsapi32.h"
#include "pchrexec.h"
#include "frmc.h"
#include "Tlhelp32.h"
// the size of the following buffer must be evenly divisible by 2 or an
// alignment fault could occur on ia64.
struct SQueuedFaultBlob
{
DWORD cbTotal;
DWORD cbFB;
DWORD_PTR dwpAppPath;
DWORD_PTR dwpModPath;
UINT64 pvOffset;
WORD rgAppVer[4];
WORD rgModVer[4];
BOOL fIs64bit;
SYSTEMTIME stFault;
};
struct SQueuePruneData
{
LPWSTR wszVal;
FILETIME ftFault;
};
///////////////////////////////////////////////////////////////////////////////
// utility functions
// **************************************************************************
BOOL GetFaultingModuleFilename(LPVOID pvFaultAddr, LPWSTR wszMod,
DWORD cchMod)
{
USE_TRACING("GetFaultingModuleFilename");
MODULEENTRY32W mod;
HRESULT hr = NOERROR;
HANDLE hSnap = INVALID_HANDLE_VALUE;
LPVOID pvEnd;
DWORD dwFlags = 0, iMod,cch;
BOOL fRet = FALSE;
VALIDATEPARM(hr, (pvFaultAddr == 0 || wszMod == NULL || cchMod == 0));
if (FAILED(hr))
goto done;
*wszMod = L'\0';
hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
TESTBOOL(hr, (hSnap != NULL));
if (FAILED(hr))
goto done;
ZeroMemory(&mod, sizeof(mod));
mod.dwSize = sizeof(mod);
TESTBOOL(hr, Module32FirstW(hSnap, &mod));
if (FAILED(hr))
goto done;
do
{
pvEnd = mod.modBaseAddr + mod.modBaseSize;
if (pvFaultAddr >= mod.modBaseAddr && pvFaultAddr < pvEnd)
{
if (cchMod > wcslen(mod.szExePath))
{
wcscpy(wszMod, mod.szExePath);
fRet = TRUE;
}
else
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
fRet = FALSE;
}
break;
}
}
while(Module32NextW(hSnap, &mod));
done:
if (hSnap != NULL)
CloseHandle(hSnap);
return fRet;
}
// **************************************************************************
EFaultRepRetVal StartDWException(LPEXCEPTION_POINTERS pep, DWORD dwOpt,
DWORD dwFlags, LPCSTR szServer,
DWORD dwTimeToWait)
{
USE_TRACING("StartDWException");
SECURITY_ATTRIBUTES sa;
PROCESS_INFORMATION pi;
EFaultRepRetVal frrvRet = frrvErrNoDW;
DWSharedMem15 *pdwsm = NULL;
STARTUPINFOW si;
HRESULT hr = NOERROR;
HANDLE hevDone = NULL, hevAlive = NULL, hmut = NULL;
HANDLE hfmShared = NULL, hProc = NULL;
HANDLE rghWait[2];
LPWSTR wszAppCompat = NULL;
WCHAR *pwszCmdLine, wszDir[MAX_PATH];
WCHAR wszAppName[MAX_PATH];
DWORD dw, dwStart, cch, cchNeed;
BOOL fDWRunning = TRUE;
ZeroMemory(&pi, sizeof(pi));
VALIDATEPARM(hr, (pep == NULL));
if (FAILED(hr))
goto done;
dwFlags |= (fDwWhistler | fDwUseHKLM | fDwAllowSuspend | fDwMiniDumpWithUnloadedModules);
// we need the following things to be inheritable, so create a SD that
// says it can be.
ZeroMemory(&sa, sizeof(sa));
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;
// create the necessary events & mutexes
hevDone = CreateEvent(&sa, FALSE, FALSE, NULL);
TESTBOOL(hr, (hevDone != NULL));
if (FAILED(hr))
goto done;
hevAlive = CreateEvent(&sa, FALSE, FALSE, NULL);
TESTBOOL(hr, (hevAlive != NULL));
if (FAILED(hr))
goto done;
hmut = CreateMutex(&sa, FALSE, NULL);
TESTBOOL(hr, (hmut != NULL));
if (FAILED(hr))
goto done;
TESTBOOL(hr, DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(),
GetCurrentProcess(), &hProc,
PROCESS_ALL_ACCESS, TRUE, 0));
if (FAILED(hr))
goto done;
// create the shared memory region & map it
hfmShared = CreateFileMapping(INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE, 0,
sizeof(DWSharedMem), NULL);
TESTBOOL(hr, (hfmShared != NULL));
if (FAILED(hr))
goto done;
pdwsm = (DWSharedMem *)MapViewOfFile(hfmShared,
FILE_MAP_READ | FILE_MAP_WRITE, 0, 0,
0);
TESTBOOL(hr, (pdwsm != NULL));
if (FAILED(hr))
goto done;
// populate all the stuff that DW needs
ZeroMemory(pdwsm, sizeof(DWSharedMem15));
pdwsm->dwSize = sizeof(DWSharedMem15);
pdwsm->pid = GetCurrentProcessId();
pdwsm->tid = GetCurrentThreadId();
pdwsm->eip = (DWORD_PTR)pep->ExceptionRecord->ExceptionAddress;
pdwsm->pep = pep;
pdwsm->hEventDone = hevDone;
pdwsm->hEventNotifyDone = NULL;
pdwsm->hEventAlive = hevAlive;
pdwsm->hMutex = hmut;
pdwsm->hProc = hProc;
pdwsm->bfDWBehaviorFlags = dwFlags;
pdwsm->msoctdsResult = msoctdsNull;
pdwsm->fReportProblem = FALSE;
pdwsm->bfmsoctdsOffer = msoctdsQuit;
pdwsm->bfmsoctdsNotify = 0;
if (dwOpt == 1)
pdwsm->bfmsoctdsOffer |= msoctdsDebug;
pdwsm->bfmsoctdsLetRun = pdwsm->bfmsoctdsOffer;
pdwsm->iPingCurrent = 0;
pdwsm->iPingEnd = 0;
pdwsm->lcidUI = GetUserDefaultUILanguage();
strcpy(pdwsm->szServer, szServer);
strcpy(pdwsm->szRegSubPath, c_szDWRegSubPath);
strcpy(pdwsm->szBrand, c_szDWBrand);
strcpy(pdwsm->szPIDRegKey, c_szRKVDigPid);
GetModuleFileNameW(NULL, pdwsm->wzModuleFileName, DW_MAX_PATH);
TESTHR(hr, GetVerName(pdwsm->wzModuleFileName, wszAppName,
sizeofSTRW(wszAppName)));
if (FAILED(hr))
goto done;
cch = CreateTempDirAndFile(NULL, c_wszACFileName, &wszAppCompat);
TESTBOOL(hr, (cch != 0));
if (SUCCEEDED(hr))
{
WCHAR wszMod[MAX_PATH], *pwszMod = NULL;
TESTBOOL(hr, GetFaultingModuleFilename(pep->ExceptionRecord->ExceptionAddress,
wszMod, sizeofSTRW(wszMod)));
if (SUCCEEDED(hr))
pwszMod = wszMod;
TESTBOOL(hr, GetAppCompatData(pdwsm->wzModuleFileName, pwszMod,
wszAppCompat));
if (SUCCEEDED(hr) && wszAppCompat != NULL &&
wcslen(wszAppCompat) < sizeofSTRW(pdwsm->wzAdditionalFile))
wcscpy(pdwsm->wzAdditionalFile, wszAppCompat);
}
wszAppName[sizeofSTRW(wszAppName) - 1] = L'\0';
wcsncpy(pdwsm->wzFormalAppName, wszAppName, DW_APPNAME_LENGTH);
// pdwsm->wzDotDataDlls[0]=0;
cch = GetSystemDirectoryW(wszDir, sizeofSTRW(wszDir));
if (cch == 0 || cch > sizeofSTRW(wszDir))
{
DBG_MSG("Bad GetSystemDirectoryW call");
goto done;
}
// the +12 is for the max size of an integer in decimal
cchNeed = cch + wcslen(wszDir) + sizeofSTRW(c_wszDWCmdLineU) + 12;
__try { pwszCmdLine = (WCHAR *)_alloca(cchNeed * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { pwszCmdLine = NULL; }
if (pwszCmdLine == NULL)
{
DBG_MSG("Out of memory");
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
swprintf(pwszCmdLine, c_wszDWCmdLineU, wszDir, hfmShared);
// create the process
ZeroMemory(&si, sizeof(si));
ZeroMemory(&pi, sizeof(pi));
// always want to launch this in the interactive workstation
si.cb = sizeof(si);
si.lpDesktop = L"Winsta0\\Default";
ErrorTrace(0, "launching [%S]", pwszCmdLine);
TESTBOOL(hr, CreateProcessW(NULL, pwszCmdLine, NULL, NULL, TRUE,
CREATE_DEFAULT_ERROR_MODE | NORMAL_PRIORITY_CLASS,
NULL, wszDir, &si, &pi));
if (FAILED(hr))
goto done;
// don't need the thread handle & we gotta close it, so close it now
CloseHandle(pi.hThread);
// assume we succeed from here on...
if ((dwFlags & fDwHeadless) == fDwHeadless)
frrvRet = frrvOkHeadless;
else
frrvRet = frrvOk;
rghWait[0] = hevAlive;
rghWait[1] = pi.hProcess;
dwStart = GetTickCount();
while(fDWRunning)
{
// gotta periodically get the Alive signal from DW.
switch(WaitForMultipleObjects(2, rghWait, FALSE, 300000))
{
case WAIT_OBJECT_0:
DBG_MSG("hevAlive signalled");
if (WaitForSingleObject(hevDone, 0) == WAIT_OBJECT_0)
{
DBG_MSG("hevDone signalled");
fDWRunning = FALSE;
}
if (dwTimeToWait != (DWORD)-1 &&
RolloverSubtract(GetTickCount(), dwStart) > dwTimeToWait)
{
frrvRet = frrvErrTimeout;
fDWRunning = FALSE;
}
continue;
case WAIT_OBJECT_0 + 1:
DBG_MSG("DW died");
fDWRunning = FALSE;
continue;
}
switch(WaitForSingleObject(hmut, DW_TIMEOUT_VALUE))
{
// yay! we got the mutex. Try to detemine if DW finally responded
// while we were grabbing the mutex.
case WAIT_OBJECT_0:
DBG_MSG("got hmut");
switch(WaitForMultipleObjects(2, rghWait, FALSE, 0))
{
// If it hasn't responded, tell it to go away & fall thru
// into the 'it died' case.
case WAIT_TIMEOUT:
DBG_MSG("wait timed out");
SetEvent(hevDone);
// It died. Clean up.
case WAIT_OBJECT_0 + 1:
DBG_MSG("wait died");
fDWRunning = FALSE;
frrvRet = frrvErrNoDW;
continue;
}
// ok, it responded. Is it done?
if (WaitForSingleObject(hevDone, 0) == WAIT_OBJECT_0)
fDWRunning = FALSE;
ReleaseMutex(hmut);
break;
// if the wait was abandoned, it means DW has gone to the great bit
// bucket in the sky without cleaning up. So release the mutex and
// fall into the default case
case WAIT_ABANDONED:
DBG_MSG("hmut timed out");
ReleaseMutex(hmut);
// if we timed out or otherwise failed, just die.
default:
DBG_MSG("hmut died");
frrvRet = frrvErrNoDW;
fDWRunning = FALSE;
break;
}
}
if (frrvRet != frrvOk)
{
DBG_MSG("not OK");
goto done;
}
// if user told us to debug, return that back to the
if (pdwsm->msoctdsResult == msoctdsDebug)
frrvRet = frrvLaunchDebugger;
// if we're going to launch Dr. Watson, wait for the DW process to die.
// Give it 5 minutes. If the user doesn't hit close by then, just return
// anyway...
if (dwOpt == (DWORD)-1)
{
if (WaitForSingleObject(pi.hProcess, 300000) == WAIT_TIMEOUT)
frrvRet = frrvErrTimeout;
}
done:
// preserve the error code so that the following calls don't overwrite it
dw = GetLastError();
if (wszAppCompat != NULL)
{
if (pi.hProcess)
WaitForSingleObject(pi.hProcess, 300000);
DeleteTempDirAndFile(wszAppCompat, TRUE);
MyFree(wszAppCompat);
}
if (pi.hProcess)
CloseHandle(pi.hProcess);
if (pdwsm != NULL)
UnmapViewOfFile(pdwsm);
if (hfmShared != NULL)
CloseHandle(hfmShared);
if (hevDone != NULL)
CloseHandle(hevDone);
if (hevAlive != NULL)
CloseHandle(hevAlive);
if (hmut != NULL)
CloseHandle(hmut);
if (hProc != NULL)
CloseHandle(hProc);
SetLastError(dw);
return frrvRet;
}
// **************************************************************************
EFaultRepRetVal StartManifestReport(LPEXCEPTION_POINTERS pep, LPWSTR wszExe,
DWORD dwOpt, DWORD dwTimeToWait)
{
USE_TRACING("StartManifestReport");
SPCHExecServFaultRequest *pesdwreq = NULL;
SPCHExecServFaultReply *pesrep = NULL;
EFaultRepRetVal frrvRet = frrvErrNoDW;
HRESULT hr = NOERROR;
DWORD cbReq, cbRead;
WCHAR wszName[MAX_PATH];
BYTE Buf[ERRORREP_PIPE_BUF_SIZE], *pBuf;
BYTE BufRep[ERRORREP_PIPE_BUF_SIZE];
VALIDATEPARM(hr, (wszExe == NULL));
if (FAILED(hr))
goto done;
ZeroMemory(Buf, sizeof(Buf));
pesdwreq = (SPCHExecServFaultRequest *)Buf;
// the following calculation ensures that pBuf is always aligned on a
// sizeof(WCHAR) boundry...
cbReq = sizeof(SPCHExecServFaultRequest) +
sizeof(SPCHExecServFaultRequest) % sizeof(WCHAR);
pBuf = Buf + cbReq;
pesdwreq->cbESR = sizeof(SPCHExecServFaultRequest);
pesdwreq->pidReqProcess = GetCurrentProcessId();
pesdwreq->thidFault = GetCurrentThreadId();
pesdwreq->pvFaultAddr = (UINT64)pep->ExceptionRecord->ExceptionAddress;
pesdwreq->pEP = (UINT64)pep;
#ifdef _WIN64
pesdwreq->fIs64bit = TRUE;
#else
pesdwreq->fIs64bit = FALSE;
#endif
// marshal in the strings
pesdwreq->wszExe = (UINT64)MarshallString(wszExe, Buf, sizeof(Buf), &pBuf,
&cbReq);
if (pesdwreq->wszExe == 0)
goto done;
pesdwreq->cbTotal = cbReq;
// check and see if the system is shutting down. If so, CreateProcess is
// gonna pop up some annoying UI that we can't get rid of, so we don't
// want to call it if we know it's gonna happen.
if (GetSystemMetrics(SM_SHUTTINGDOWN))
goto done;
// Send the buffer out to the server- wait at most 2m for this to
// succeed. If it times out, bail. BTW, need to zero out BufRep here
// cuz the call to the named pipe CAN fail & we don't want to start
// processing garbage results...
ZeroMemory(BufRep, sizeof(BufRep));
wcscpy(wszName, ERRORREP_FAULT_PIPENAME);
TESTHR(hr, MyCallNamedPipe(wszName, Buf, cbReq, BufRep, sizeof(BufRep),
&cbRead, 120000, 120000));
if (FAILED(hr))
{
// determine the error code that indicates whether we've timed out so
// we can set the return code appropriately.
goto done;
}
pesrep = (SPCHExecServFaultReply *)BufRep;
// did the call succeed?
VALIDATEEXPR(hr, (pesrep->ess == essErr), Err2HR(pesrep->dwErr));
if (FAILED(hr))
{
SetLastError(pesrep->dwErr);
goto done;
}
// this is only necessary if we actually launched DW. If we just queued
// the fault for later, then we obviously can't wait on DW.
if (pesrep->ess == essOk)
{
DWORD dwExitCode = msoctdsNull;
// gotta wait for DW to be done before we nuke the manifest file, but
// if it hasn't parsed it in 5 minutes, something's wrong with it.
if (pesrep->hProcess != NULL)
{
DWORD dwTimeout;
// so, if we're going to pop up the JIT debugger dialog if we timeout,
// then maybe we should just not bother timeing out...
dwTimeout = (dwOpt == froDebug) ? INFINITE : 300000;
if (WaitForSingleObject(pesrep->hProcess, dwTimeout) == WAIT_TIMEOUT)
frrvRet = frrvErrTimeout;
// see if we need to debug the process
else if (GetExitCodeProcess(pesrep->hProcess, &dwExitCode) == FALSE)
dwExitCode = msoctdsNull;
CloseHandle(pesrep->hProcess);
pesrep->hProcess = NULL;
}
// we're only going to delete the files if DW has finished with them.
// Yes this means we can leave stray files in the temp dir, but this
// is better than having DW randomly fail while sending...
if (frrvRet != frrvErrTimeout)
{
LPWSTR pwsz, pwszEnd;
if (pesrep->wszDir != 0)
{
if (pesrep->wszDir < cbRead &&
pesrep->wszDir >= sizeof(SPCHExecServFaultReply))
pesrep->wszDir += (UINT64)pesrep;
else
pesrep->wszDir = 0;
}
if (pesrep->wszDumpName != 0)
{
if (pesrep->wszDumpName < cbRead &&
pesrep->wszDumpName >= sizeof(SPCHExecServFaultReply))
pesrep->wszDumpName += (UINT64)pesrep;
else
pesrep->wszDumpName = 0;
}
// make sure that there is a NULL terminator for each string
// before the end of the buffer...
pwszEnd = (LPWSTR)((BYTE *)pesrep + cbRead);
if (pesrep->wszDumpName != 0)
{
for (pwsz = (LPWSTR)pesrep->wszDumpName;
pwsz < pwszEnd && *pwsz != L'\0';
pwsz++);
if (*pwsz != L'\0')
pesrep->wszDumpName = 0;
}
if (pesrep->wszDir != 0)
{
for (pwsz = (LPWSTR)pesrep->wszDir;
pwsz < pwszEnd && *pwsz != L'\0';
pwsz++);
if (*pwsz != L'\0')
pesrep->wszDir = 0;
}
}
frrvRet = (dwExitCode == msoctdsDebug) ? frrvLaunchDebugger :
frrvOkManifest;
}
// if we queued it, set the appropriate return code (duh)
else if (pesrep->ess == essOkQueued)
{
frrvRet = frrvOkQueued;
}
SetLastError(0);
done:
if ((frrvRet == frrvOkManifest || frrvRet == frrvLaunchDebugger) &&
pesrep != NULL && pesrep->wszDir != 0)
{
LPWSTR wszToDel = NULL;
DWORD cchDir = 0, cchFile = 0;
cchDir = wcslen((LPWSTR)pesrep->wszDir);
if (pesrep->wszDumpName != 0)
cchFile = wcslen((LPWSTR)pesrep->wszDumpName);
if (cchFile < sizeofSTRW(c_wszACFileName))
cchFile = sizeofSTRW(c_wszACFileName);
if (cchFile < sizeofSTRW(c_wszManFileName))
cchFile = sizeofSTRW(c_wszManFileName);
__try { wszToDel = (LPWSTR)_alloca((cchFile + cchDir + 4) * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszToDel = NULL; }
if (wszToDel != NULL)
{
LPWSTR pwszToDel;
wcscpy(wszToDel, (LPWSTR)pesrep->wszDir);
pwszToDel = wszToDel + cchDir;
*pwszToDel++ = L'\\';
if (pesrep->wszDumpName != 0)
{
wcscpy(pwszToDel, (LPWSTR)pesrep->wszDumpName);
#ifdef MANIFEST_HEAP
DeleteFullAndTriageMiniDumps(wszToDel);
#else
DeleteFileW(wszToDel);
#endif
}
wcscpy(pwszToDel, c_wszACFileName);
DeleteFileW(wszToDel);
wcscpy(pwszToDel, c_wszManFileName);
DeleteFileW(wszToDel);
}
DeleteTempDirAndFile((LPWSTR)pesrep->wszDir, FALSE);
}
return frrvRet;
}
// **************************************************************************
HRESULT PruneQ(HKEY hkeyQ, DWORD cQSize, DWORD cMaxQSize, DWORD cchMaxVal,
DWORD cbMaxData)
{
USE_TRACING("PruneQ");
SQueuedFaultBlob *psqfb = NULL;
SQueuePruneData *pqpd = NULL;
FILETIME ft;
HRESULT hr = NOERROR;
LPWSTR pwsz, pwszCurrent = NULL;
DWORD cchVal, cbData, dwType, cToDel = 0, cInDelList = 0;
DWORD i, iEntry, dw, cValid = 0;
VALIDATEPARM(hr, (hkeyQ == NULL));
if (FAILED(hr))
goto done;
if (cMaxQSize > cQSize)
goto done;
cToDel = cQSize - cMaxQSize + 1;
// alloc the various buffers that we'll need:
// the delete list
// the current file we're working with
// the data blob associated with the current file
cbData = (sizeof(SQueuePruneData) + (cchMaxVal * sizeof(WCHAR))) * cToDel;
pwszCurrent = (LPWSTR)MyAlloc(cchMaxVal * sizeof(WCHAR));
psqfb = (SQueuedFaultBlob *)MyAlloc(cbMaxData);
pqpd = (SQueuePruneData *)MyAlloc(cbData);
if (psqfb == NULL || pwszCurrent == NULL || pqpd == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
hr = E_OUTOFMEMORY;
goto done;
}
// intiailize all the string pointers in the delete list
pwsz = (LPWSTR)((BYTE *)pqpd + (sizeof(SQueuePruneData) * cToDel));
for (i = 0; i < cToDel; i++)
{
pqpd[i].ftFault.dwHighDateTime = 0;
pqpd[i].ftFault.dwLowDateTime = 0;
pqpd[i].wszVal = pwsz;
pqpd[i].wszVal[0] = L'\0';
pwsz += cchMaxVal;
}
// ok, get a list of all the valid items and build an array in sorted order
// so that we can easily pick off the top n items
for(iEntry = 0; iEntry < cQSize; iEntry++)
{
cchVal = cchMaxVal;
cbData = cbMaxData;
dw = RegEnumValueW(hkeyQ, iEntry, pwszCurrent, &cchVal, 0, &dwType,
(PBYTE)psqfb, &cbData);
if (dw == ERROR_NO_MORE_ITEMS)
break;
else if (dw != ERROR_SUCCESS)
continue;
else if (cbData < sizeof(SQueuedFaultBlob) ||
psqfb->cbFB != sizeof(SQueuedFaultBlob) ||
psqfb->cbTotal != cbData)
{
RegDeleteValueW(hkeyQ, pwszCurrent);
DeleteFileW(pwszCurrent);
continue;
}
SystemTimeToFileTime(&psqfb->stFault, &ft);
for (i = 0; i < cInDelList; i++)
{
if ((ft.dwHighDateTime < pqpd[i].ftFault.dwHighDateTime) ||
(ft.dwHighDateTime == pqpd[i].ftFault.dwHighDateTime &&
ft.dwLowDateTime < pqpd[i].ftFault.dwLowDateTime))
break;
}
// if it's in the middle of the current list, then we gotta move
// stuff around
if (cInDelList > 0 && i < cInDelList - 1)
{
LPWSTR pwszTemp = pqpd[cInDelList - 1].wszVal;
MoveMemory(&pqpd[i], &pqpd[i + 1],
(cInDelList - i) * sizeof(SQueuePruneData));
pqpd[i].wszVal = pwszTemp;
}
if (i < cToDel)
{
// note that this copy is safe cuz each string slot is the same
// size as the buffer pointed to by pwszCurrent and that buffer is
// protected from overflow by the size we pass into
// RegEnumValueW()
wcscpy(pqpd[i].wszVal, pwszCurrent);
pqpd[i].ftFault = ft;
if (cInDelList < cToDel)
cInDelList++;
}
cValid++;
}
// if there aren't enuf valid entries to warrant a purge, then don't purge
if (cValid < cMaxQSize)
goto done;
cToDel = MyMin(cToDel, cValid - cMaxQSize + 1);
// purge enuf entries that we go down to 1 below our max (since we have to
// be adding 1 to get here- don't want that 1 to drive us over the limit
for(i = 0; i < cToDel; i++)
{
if (pqpd[i].wszVal != NULL)
{
DeleteFileW(pqpd[i].wszVal);
RegDeleteValueW(hkeyQ, pqpd[i].wszVal);
}
}
done:
if (pqpd != NULL)
MyFree(pqpd);
if (psqfb != NULL)
MyFree(psqfb);
if (pwszCurrent != NULL)
MyFree(pwszCurrent);
return hr;
}
// **************************************************************************
HRESULT CheckQSizeAndPrune(HKEY hkeyQ)
{
USE_TRACING("CheckQueueSizeAndPrune");
HRESULT hr = NOERROR;
HANDLE hmut = NULL;
DWORD cMaxQSize = 0, cDefMaxQSize = 10;
DWORD cQSize, cchMaxVal, cbMaxData;
DWORD cb, dw;
HKEY hkey = NULL;
VALIDATEPARM(hr, (hkeyQ == NULL));
if (FAILED(hr))
goto done;
// find out the max Q size
TESTHR(hr, OpenRegKey(HKEY_LOCAL_MACHINE, c_wszRPCfg, 0, &hkey));
if (FAILED(hr))
goto done;
cb = sizeof(cMaxQSize);
TESTHR(hr, ReadRegEntry(hkey, c_wszRVMaxQueueSize, NULL, (PBYTE)&cMaxQSize,
&cb, (PBYTE)&cDefMaxQSize, sizeof(cDefMaxQSize)));
RegCloseKey(hkey);
hkey = NULL;
if (FAILED(hr))
goto done;
// if the Q size is 0, then we are effectively disabled for Qing faults.
// Return S_FALSE to indicate this
if (cMaxQSize == 0)
{
hr = S_FALSE;
goto done;
}
// -1 means there is no limit
else if (cMaxQSize == (DWORD)-1)
{
hr = NOERROR;
goto done;
}
else if (cMaxQSize > c_cMaxQueue)
cMaxQSize = c_cMaxQueue;
hmut = OpenMutexW(SYNCHRONIZE, FALSE, c_wszMutUserName);
TESTBOOL(hr, (hmut != NULL));
if (FAILED(hr))
goto done;
// wait for 5s for the mutex to become available- this should be enuf time
// for anyone else to add something to the queue dir. It could take longer
// if someone is processing the dir, but then items are being removed
// anyway...
dw = WaitForSingleObject(hmut, 5000);
if (dw != WAIT_OBJECT_0)
{
// if the wait timed out, then someone is already going thru the faults
// so it's likely to be reduced sometime soon
if (dw == WAIT_TIMEOUT)
hr = NOERROR;
else
hr = Err2HR(GetLastError());
goto done;
}
__try
{
// determine what the Q size is.
TESTERR(hr, RegQueryInfoKey(hkeyQ, NULL, NULL, NULL, NULL, NULL, NULL,
&cQSize, &cchMaxVal, &cbMaxData, NULL, NULL));
if (SUCCEEDED(hr) && (cQSize >= cMaxQSize))
{
cchMaxVal++;
TESTHR(hr, PruneQ(hkeyQ, cQSize, cMaxQSize, cchMaxVal, cbMaxData));
}
else
{
hr = NOERROR;
}
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
}
done:
if (hmut != NULL)
{
ReleaseMutex(hmut);
CloseHandle(hmut);
}
return hr;
}
///////////////////////////////////////////////////////////////////////////////
// exported functions
// **************************************************************************
EFaultRepRetVal APIENTRY ReportFaultFromQueue(LPWSTR wszDump, BYTE *pbData,
DWORD cbData)
{
USE_TRACING("ReportFaultFromQueue");
CPFFaultClientCfg oCfg;
SQueuedFaultBlob *pqfb = (SQueuedFaultBlob *)pbData;
EFaultRepRetVal frrvRet = frrvErrNoDW;
SDWManifestBlob dwmb;
SYSTEMTIME stLocal;
FILETIME ft, ftLocal;
HRESULT hr = NOERROR;
LPWSTR wszAppPath, wszModPath;
LPWSTR wszModName, wszAppName, pwszApp, pwszEnd;
LPWSTR wszStage1, wszStage2, wszCorpPath, wszHdr, wszErrMsg;
LPWSTR wszNewDump = NULL, wszDir = NULL;
LPWSTR wszManifest = NULL, pwszAppCompat = NULL;
WCHAR wszDate[128], wszTime[128], *pwsz;
WCHAR *pwch;
WCHAR wszAppFriendlyName[MAX_PATH];
WCHAR wszBuffer[160];
WCHAR wszUnknown[] = L"unknown";
DWORD dw, cchTotal, cchSep = 0, cch, cchDir;
BYTE *pbBuf = NULL;
BOOL fMSApp = FALSE, fAllowSend = TRUE, fOkCopy = FALSE;
VALIDATEPARM(hr, (wszDump == NULL || pbData == NULL) ||
cbData < sizeof(SQueuedFaultBlob) ||
pqfb->cbFB != sizeof(SQueuedFaultBlob) ||
pqfb->cbTotal != cbData ||
pqfb->dwpAppPath >= cbData ||
pqfb->dwpModPath >= cbData);
if (FAILED(hr))
goto done;
wszAppPath = (LPWSTR)(pqfb->dwpAppPath + pbData);
wszModPath = (LPWSTR)(pqfb->dwpModPath + pbData);
pwszEnd = (LPWSTR)(pbData + cbData);
// make sure there's a NULL terminator on the ModPath string before the end
// of the buffer...
for (pwch = wszModPath; pwch < pwszEnd && *pwch != L'\0'; pwch++);
if (pwch >= pwszEnd)
{
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
// convieniently, pwch is now at the end of ModPath string, so we can
// parse back to find the first backslash & get the module name
for(pwch -= 1; pwch >= wszModPath && *pwch != L'\\'; pwch--);
if (*pwch == L'\\')
wszModName = pwch + 1;
else
wszModName = wszModPath;
if (*wszModName == L'\0')
wszModName = wszUnknown;
// make sure there's a NULL terminator on the AppPath string before the end
// of the buffer...
for (pwch = wszAppPath; pwch < wszModPath && *pwch != L'\0'; pwch++);
if (pwch >= wszModPath)
{
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
// convieniently, pwch is now at the end of AppPath string, so we can
// parse back to find the first backslash & get the module name
for(pwch -= 1; pwch >= wszAppPath && *pwch != L'\\'; pwch--);
if (*pwch == L'\\')
wszAppName = pwch + 1;
else
wszAppName = wszAppPath;
// get the config info
TESTHR(hr, oCfg.Read(eroPolicyRO));
if (FAILED(hr))
goto done;
if (oCfg.get_ShowUI() == eedDisabled && oCfg.get_DoReport() == eedDisabled)
goto done;
// figure out how we're reporting / notifying the user
if (oCfg.get_DoReport() == eedDisabled ||
oCfg.ShouldCollect(wszAppPath, &fMSApp) == FALSE)
fAllowSend = FALSE;
if (oCfg.get_ShowUI() == eedDisabled)
{
LPCWSTR wszULPath = oCfg.get_DumpPath(NULL, 0);
// check and make sure that we have a corporate path specified. If we
// don't, bail
if (wszULPath == NULL || *wszULPath == L'\0')
goto done;
}
// log an event- don't care if it fails or not.
TESTHR(hr, LogUser(wszAppName, pqfb->rgAppVer, wszModName, pqfb->rgModVer,
pqfb->pvOffset, pqfb->fIs64bit, ER_QUEUEREPORT_LOG));
if (CreateTempDirAndFile(NULL, NULL, &wszDir) == 0)
goto done;
cchDir = wcslen(wszDir);
cch = cchDir + sizeofSTRW(c_wszManFileName) + 4;
__try { wszManifest = (LPWSTR)_alloca(cch * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszManifest = NULL; }
if (wszManifest == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
wcscpy(wszManifest, wszDir);
wszManifest[cchDir] = L'\\';
wszManifest[cchDir + 1] = L'\0';
wcscat(wszManifest, c_wszManFileName);
cchDir = wcslen(wszDir);
cch = 2 * cchDir + wcslen(wszDump) + sizeofSTRW(c_wszACFileName) + 4;
__try { wszNewDump = (LPWSTR)_alloca(cch * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszNewDump = NULL; }
if (wszNewDump == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
wcscpy(wszNewDump, wszDir);
wszNewDump[cchDir] = L'\\';
wszNewDump[cchDir + 1] = L'\0';
fOkCopy = FALSE;
for (pwsz = wszDump + wcslen(wszDump);
*pwsz != L'\\' && pwsz > wszDump;
pwsz--);
if (*pwsz == L'\\')
{
pwsz++;
wcscat(wszNewDump, pwsz);
for (pwsz = wszNewDump + wcslen(wszNewDump);
*pwsz != L'.' && pwsz > wszNewDump;
pwsz--);
if (*pwsz == L'.' && pwsz > wszNewDump &&
_wcsicmp(pwsz, c_wszDumpSuffix) == 0)
{
pwsz--;
for(;
*pwsz != L'.' && pwsz > wszNewDump;
pwsz--);
if (*pwsz == L'.' && pwsz > wszNewDump)
{
wcscpy(pwsz, c_wszDumpSuffix);
#ifdef MANIFEST_HEAP
fOkCopy = CopyFullAndTriageMiniDumps(wszDump, wszNewDump);
#else
fOkCopy = CopyFileW(wszDump, wszNewDump, FALSE);
#endif
}
}
}
if (fOkCopy == FALSE)
wcscpy(wszNewDump, wszDump);
// generate all the URLs / filepaths that we need...
TESTHR(hr, BuildManifestURLs(wszAppName, wszModName, pqfb->rgAppVer,
pqfb->rgModVer, pqfb->pvOffset,
pqfb->fIs64bit, &wszStage1, &wszStage2,
&wszCorpPath, &pbBuf));
if (FAILED(hr))
goto done;
// get the friendly name for the app
TESTHR(hr, GetVerName(wszAppPath, wszAppFriendlyName,
sizeofSTRW(wszAppFriendlyName)));
if (FAILED(hr))
goto done;
wszAppFriendlyName[sizeofSTRW(wszAppFriendlyName) - 1] = L'\0';
// build the header string
dw = LoadStringW(g_hInstance, IDS_FQHDRTXT, wszBuffer,
sizeofSTRW(wszBuffer));
if (dw == 0)
goto done;
cchTotal = dw + wcslen(wszAppFriendlyName) + 1;
__try { wszHdr = (LPWSTR)_alloca(cchTotal * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszHdr = NULL; }
if (wszHdr == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
swprintf(wszHdr, wszBuffer, wszAppFriendlyName);
// need to convert the time of the fault to a local time (cuz
// GetSystemTime() returns a UTC time), but unfortunately, only filetimes
// can be converted back and forth between UTC & local, so we have to do
// all of this stuff...
SystemTimeToFileTime(&pqfb->stFault, &ft);
FileTimeToLocalFileTime(&ft, &ftLocal);
FileTimeToSystemTime(&ftLocal, &stLocal);
// build the error message string
dw = LoadStringW(g_hInstance, IDS_FQERRMSG, wszBuffer,
sizeofSTRW(wszBuffer));
if (dw == 0)
goto done;
cchTotal = dw;
dw = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stLocal,
NULL, wszDate, sizeofSTRW(wszDate));
if (dw == 0)
goto done;
cchTotal += dw;
dw = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &stLocal, NULL, wszTime,
sizeofSTRW(wszTime));
if (dw == 0)
goto done;
cchTotal += dw;
cchTotal++;
__try { wszErrMsg = (LPWSTR)_alloca(cchTotal * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszErrMsg = NULL; }
if (wszErrMsg == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
swprintf(wszErrMsg, wszBuffer, wszDate, wszTime);
// we created the wszDump buffer above big enuf to hold both the
// dumpfile path as well as the app compat filename. So make
// use of that right now.
cchSep = wcslen(wszNewDump);
pwszAppCompat = wszNewDump + cchSep + 1;
wcscpy(pwszAppCompat, wszDir);
pwszAppCompat[cchDir] = L'\\';
pwszAppCompat[cchDir + 1] = L'\0';
wcscat(pwszAppCompat, c_wszACFileName);
// if we succeed, turn the NULL following the dump file path into
// the DW separator character
TESTBOOL(hr, GetAppCompatData(wszAppPath, wszModPath, pwszAppCompat));
if (SUCCEEDED(hr))
wszNewDump[cchSep] = DW_FILESEP;
ZeroMemory(&dwmb, sizeof(dwmb));
dwmb.wszTitle = wszAppFriendlyName;
dwmb.wszErrMsg = wszErrMsg;
dwmb.wszHdr = wszHdr;
dwmb.wszStage1 = wszStage1;
dwmb.wszStage2 = wszStage2;
dwmb.wszBrand = c_wszDWBrand;
dwmb.wszFileList = wszNewDump;
dwmb.fIsMSApp = fMSApp;
dwmb.wszCorpPath = wszCorpPath;
// check and see if the system is shutting down. If so, CreateProcess is
// gonna pop up some annoying UI that we can't get rid of, so we don't
// want to call it if we know it's gonna happen.
if (GetSystemMetrics(SM_SHUTTINGDOWN))
goto done;
// we get back the name of the manifest file here.
frrvRet = StartDWManifest(oCfg, dwmb, wszManifest, fAllowSend);
done:
dw = GetLastError();
if (pbBuf != NULL)
MyFree(pbBuf);
if (frrvRet != frrvErrTimeout)
{
if (wszNewDump != NULL)
{
if (pwszAppCompat != NULL)
{
wszNewDump[cchSep] = L'\0';
DeleteFileW(pwszAppCompat);
}
#ifdef MANIFEST_HEAP
DeleteFullAndTriageMiniDumps(wszNewDump);
#else
DeleteFileW(wszNewDump);
#endif
}
if (wszManifest != NULL)
DeleteFileW(wszManifest);
if (wszDir != NULL)
{
DeleteTempDirAndFile(wszDir, FALSE);
MyFree(wszDir);
}
}
SetLastError(dw);
return frrvRet;
}
// **************************************************************************
#define ER_ALL_RIGHTS GENERIC_ALL | STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL
EFaultRepRetVal APIENTRY ReportFaultToQueue(SFaultRepManifest *pfrm)
{
USE_TRACING("ReportFaultToQueue");
SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
SQueuedFaultBlob *pqfb;
EFaultRepRetVal frrvRet = frrvErrNoDW;
SMDumpOptions smdo;
SYSTEMTIME st;
HRESULT hr = NOERROR;
LPWSTR pwsz, pwszAppName = NULL, pwszDump = NULL;
HANDLE hFile = INVALID_HANDLE_VALUE;
HANDLE hProc = NULL;
USHORT usCompress;
DWORD cch, cchNeed, cb, dw;
WCHAR wszDump[MAX_PATH];
HKEY hkeyQ = NULL, hkeyRun = NULL;
WORD iFile = 0;
ZeroMemory(&sa, sizeof(sa));
wszDump[0] = L'\0';
VALIDATEPARM(hr, (pfrm == NULL || pfrm->wszExe == NULL ||
pfrm->pidReqProcess == 0));
if (FAILED(hr))
goto done;
// get the SD for the file we need to create
TESTBOOL(hr, AllocSD(&sd, ER_ALL_RIGHTS, ER_ALL_RIGHTS, 0));
if (FAILED(hr))
goto done;
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
// get the name of the faulting application
for (pwszAppName = pfrm->wszExe + wcslen(pfrm->wszExe) - 1;
*pwszAppName != L'\\' && pwszAppName >= pfrm->wszExe;
pwszAppName--);
if (*pwszAppName == L'\\')
pwszAppName++;
// generate the filename
cch = GetSystemWindowsDirectoryW(wszDump, sizeofSTRW(wszDump));
if (cch == 0)
goto done;
// compute minimum required buffer size needed (the '5 * 6' at the end is
// to allow for the 6 WORD values that will be inserted)
cchNeed = cch + wcslen(pwszAppName) + 5 * 6 + sizeofSTRW(c_wszQFileName);
if (cchNeed > sizeofSTRW(wszDump))
{
__try { pwszDump = (LPWSTR)_alloca(cchNeed * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { pwszDump = NULL; }
if (pwszDump == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
if (cch > sizeofSTRW(wszDump))
cch = GetSystemWindowsDirectoryW(wszDump, cchNeed);
else
wcscpy(pwszDump, wszDump);
}
else
{
pwszDump = wszDump;
}
pwsz = pwszDump + cch - 1;
if (*pwsz != L'\\')
{
*(++pwsz) = L'\\';
*(++pwsz) = L'\0';
}
wcscpy(pwsz, c_wszQSubdir);
pwsz += (sizeofSTRW(c_wszQSubdir) - 1);
GetSystemTime(&st);
swprintf(pwsz, c_wszQFileName, pwszAppName, st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond);
// set pwsz to point to the 00 at the end of the above string...
pwsz += (wcslen(pwsz) - 7);
// do this in this section to make sure we can open these keys
TESTHR(hr, OpenRegKey(HKEY_LOCAL_MACHINE, c_wszRKUser, orkWantWrite,
&hkeyQ));
if (FAILED(hr))
goto done;
TESTHR(hr, OpenRegKey(HKEY_LOCAL_MACHINE, c_wszRKRun, orkWantWrite,
&hkeyRun));
if (FAILED(hr))
goto done;
// check the size of the file Q and purge it if necessary
TESTHR(hr, CheckQSizeAndPrune(hkeyQ));
if (FAILED(hr) || hr == S_FALSE)
goto done;
for(iFile = 1; iFile <= 100; iFile++)
{
hFile = CreateFileW(pwszDump, GENERIC_WRITE | GENERIC_READ, 0, &sa,
CREATE_NEW, 0, NULL);
if (hFile != INVALID_HANDLE_VALUE)
break;
if (hFile == INVALID_HANDLE_VALUE &&
GetLastError() != ERROR_FILE_EXISTS)
break;
*pwsz = L'0' + (WCHAR)(iFile / 10);
*(pwsz + 1) = L'0' + (WCHAR)(iFile % 10);
}
if (hFile == INVALID_HANDLE_VALUE)
goto done;
// get a handle to the target process
hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE,
pfrm->pidReqProcess);
if (hProc == NULL)
goto done;
// generate the minidump
ZeroMemory(&smdo, sizeof(smdo));
#ifdef MANIFEST_HEAP
smdo.ulThread = c_ulThreadWriteDefault;
smdo.ulMod = c_ulModuleWriteDefault;
#else
smdo.ulThread = ThreadWriteThread | ThreadWriteContext | ThreadWriteStack;
smdo.ulMod = ModuleWriteModule | ModuleWriteMiscRecord | ModuleWriteDataSeg;
#endif
smdo.dwThreadID = pfrm->thidFault;
smdo.dfOptions = dfCollectSig;
smdo.pvFaultAddr = pfrm->pvFaultAddr;
smdo.pEP = pfrm->pEP;
smdo.fEPClient = TRUE;
smdo.wszModFullPath[0] = L'\0';
wcscpy(smdo.wszAppFullPath, pfrm->wszExe);
wcscpy(smdo.wszMod, L"unknown");
#ifdef MANIFEST_HEAP
TESTBOOL(hr, InternalGenFullAndTriageMinidumps(hProc, pfrm->pidReqProcess,
pwszDump, hFile, &smdo, pfrm->fIs64bit));
#else
TESTBOOL(hr, InternalGenerateMinidump(hProc, pfrm->pidReqProcess, hFile,
&smdo, pwszDump));
#endif
if (FAILED(hr))
goto done;
// set the file to use NTFS compression- it is ok if this fails.
usCompress = COMPRESSION_FORMAT_DEFAULT;
TESTBOOL(hr, DeviceIoControl(hFile, FSCTL_SET_COMPRESSION, &usCompress,
sizeof(usCompress), NULL, 0, &cb, NULL));
// log an event- don't care if it fails or not.
TESTHR(hr, LogUser(smdo.wszApp, smdo.rgAppVer, smdo.wszMod, smdo.rgModVer,
smdo.pvOffset, pfrm->fIs64bit, ER_USERCRASH_LOG));
// build the blob we'll store with the filename in the registry
cch = wcslen(smdo.wszAppFullPath) + 1;
cb = sizeof(SQueuedFaultBlob) +
(cch + wcslen(smdo.wszModFullPath) + 2) * sizeof(WCHAR);
__try { pqfb = (SQueuedFaultBlob *)_alloca(cb); }
__except(EXCEPTION_STACK_OVERFLOW) { pqfb = NULL; }
if (pqfb == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
CopyMemory(&pqfb->rgAppVer, &smdo.rgAppVer, 4 * sizeof(DWORD));
CopyMemory(&pqfb->rgModVer, &smdo.rgModVer, 4 * sizeof(DWORD));
CopyMemory(&pqfb->stFault, &st, sizeof(st));
pqfb->cbFB = sizeof(SQueuedFaultBlob);
pqfb->cbTotal = cb;
pqfb->fIs64bit = pfrm->fIs64bit;
pqfb->pvOffset = smdo.pvOffset;
pwsz = (WCHAR *)((BYTE *)pqfb + sizeof(SQueuedFaultBlob));
pqfb->dwpAppPath = sizeof(SQueuedFaultBlob);
pqfb->dwpModPath = sizeof(SQueuedFaultBlob) + cch * sizeof(WCHAR);
CopyMemory(pwsz, smdo.wszAppFullPath, cch * sizeof(WCHAR));
pwsz += cch;
wcscpy(pwsz, smdo.wszModFullPath);
// write out the value to our 'queue' in the registry.
TESTERR(hr, RegSetValueExW(hkeyQ, pwszDump, 0, REG_BINARY, (LPBYTE)pqfb,
cb));
if (FAILED(hr))
goto done;
// write out our app to the 'run' key so that the next admin to log
// in will see that a fault has occurred.
TESTERR(hr, RegSetValueExW(hkeyRun, c_wszRVUFC, 0, REG_EXPAND_SZ,
(LPBYTE)c_wszRVVUFC, sizeof(c_wszRVVUFC)));
if (FAILED(hr))
{
RegDeleteValueW(hkeyQ, pwszDump);
goto done;
}
frrvRet = frrvOk;
done:
dw = GetLastError();
// if we failed, then clean everything up.
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
if (frrvRet != frrvOk && iFile <= 100 && pwszDump != NULL)
DeleteFileW(pwszDump);
if (sa.lpSecurityDescriptor != NULL)
FreeSD((SECURITY_DESCRIPTOR *)sa.lpSecurityDescriptor);
if (hkeyQ != NULL)
RegCloseKey(hkeyQ);
if (hkeyRun != NULL)
RegCloseKey(hkeyRun);
if (hProc != NULL)
CloseHandle(hProc);
SetLastError(dw);
return frrvRet;
}
// **************************************************************************
EFaultRepRetVal APIENTRY ReportFaultDWM(SFaultRepManifest *pfrm,
LPCWSTR wszDir, HANDLE hToken,
LPVOID pvEnv, PROCESS_INFORMATION *ppi,
LPWSTR wszDumpFile)
{
USE_TRACING("ReportFaultDWM");
CPFFaultClientCfg oCfg;
EFaultRepRetVal frrvRet = frrvErrNoDW;
SDWManifestBlob dwmb;
SMDumpOptions smdo;
HRESULT hr = NOERROR;
HANDLE hProc = NULL;
#ifndef MANIFEST_HEAP
HANDLE hFile = INVALID_HANDLE_VALUE;
#endif
LPWSTR wszStage1, wszStage2, wszCorpPath;
LPWSTR wszManifest = NULL, wszDump = NULL, pwszAppCompat = NULL;
DWORD dw, cch, cchDir, cchSep = 0;
WCHAR wszAppName[MAX_PATH];
HKEY hkeyDebug = NULL;
BOOL fAllowSend = TRUE, fMSApp = FALSE, fShowDebug = FALSE;
BYTE *pbBuf = NULL;
VALIDATEPARM(hr, (pfrm == NULL || pfrm->wszExe == NULL || ppi == NULL ||
wszDir == NULL || hToken == NULL || wszDumpFile == NULL ||
wszDir[0] == L'\0'));
if (FAILED(hr))
{
SetLastError(ERROR_INVALID_PARAMETER);
goto done;
}
// get the config info
TESTHR(hr, oCfg.Read(eroPolicyRO));
if (FAILED(hr))
goto done;
if (oCfg.get_ShowUI() == eedDisabled && oCfg.get_DoReport() == eedDisabled)
goto done;
// figure out how we're reporting / notifying the user
if (oCfg.get_DoReport() == eedDisabled ||
oCfg.ShouldCollect(pfrm->wszExe, &fMSApp) == FALSE)
fAllowSend = FALSE;
if (oCfg.get_ShowUI() == eedDisabled)
{
LPCWSTR wszULPath = oCfg.get_DumpPath(NULL, 0);
// check and make sure that we have a corporate path specified. If we
// don't, bail
if (wszULPath == NULL || *wszULPath == L'\0')
goto done;
}
cchDir = wcslen(wszDir);
cch = cchDir + sizeofSTRW(c_wszManFileName) + 4;
__try { wszManifest = (LPWSTR)_alloca(cch * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszManifest = NULL; }
if (wszManifest == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
wcscpy(wszManifest, wszDir);
wszManifest[cchDir] = L'\\';
wszManifest[cchDir + 1] = L'\0';
wcscat(wszManifest, c_wszManFileName);
cchDir = wcslen(wszDir);
cch = 2 * cchDir + wcslen(wszDumpFile) + sizeofSTRW(c_wszACFileName) + 4;
__try { wszDump = (LPWSTR)_alloca(cch * sizeof(WCHAR)); }
__except(EXCEPTION_STACK_OVERFLOW) { wszDump = NULL; }
if (wszDump == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
goto done;
}
wcscpy(wszDump, wszDir);
wszDump[cchDir] = L'\\';
wszDump[cchDir + 1] = L'\0';
wcscat(wszDump, wszDumpFile);
// checlk and see if we need to put a debug button on the DW dialog
dw = RegOpenKeyExW(HKEY_LOCAL_MACHINE, c_wszRKAeDebug, 0, KEY_READ,
&hkeyDebug);
if (dw == ERROR_SUCCESS)
{
LPWSTR wszDebugger;
WCHAR wszAuto[32];
DWORD dwType, cbNeed;
cbNeed = sizeof(wszAuto);
dw = RegQueryValueExW(hkeyDebug, c_wszRVAuto, NULL, &dwType,
(LPBYTE)wszAuto, &cbNeed);
if (dw != ERROR_SUCCESS || cbNeed == 0 || dwType != REG_SZ)
goto doneDebugCheck;
// only way to get here if Auto == 1 is if drwtsn32 is the JIT debugger
if (wszAuto[0] == L'1')
goto doneDebugCheck;
cbNeed = 0;
dw = RegQueryValueExW(hkeyDebug, c_wszRVDebugger, NULL, &dwType, NULL,
&cbNeed);
if (dw != ERROR_SUCCESS || cbNeed == 0 || dwType != REG_SZ)
goto doneDebugCheck;
cbNeed += sizeof(WCHAR);
__try { wszDebugger = (LPWSTR)_alloca(cbNeed); }
__except(EXCEPTION_STACK_OVERFLOW) { wszDebugger = NULL; }
if (wszDebugger == NULL)
goto doneDebugCheck;
dw = RegQueryValueExW(hkeyDebug, c_wszRVDebugger, NULL, NULL,
(LPBYTE)wszDebugger, &cbNeed);
if (dw != ERROR_SUCCESS)
goto doneDebugCheck;
if (wszDebugger[0] != L'\0')
fShowDebug = TRUE;
doneDebugCheck:
RegCloseKey(hkeyDebug);
hkeyDebug = NULL;
}
#ifndef MANIFEST_HEAP
hFile = CreateFileW(wszDump, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
SetLastError(dw);
goto done;
}
#endif // !MANIFEST_HEAP
// get a handle to the target process
hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE,
pfrm->pidReqProcess);
if (hProc == NULL)
goto done;
// generate the minidump
ZeroMemory(&smdo, sizeof(smdo));
#ifdef MANIFEST_HEAP
smdo.ulThread = c_ulThreadWriteDefault;
smdo.ulMod = c_ulModuleWriteDefault;
#else
smdo.ulThread = ThreadWriteThread | ThreadWriteContext | ThreadWriteStack;
smdo.ulMod = ModuleWriteModule | ModuleWriteMiscRecord | ModuleWriteDataSeg;
#endif
smdo.dwThreadID = pfrm->thidFault;
smdo.dfOptions = dfCollectSig;
smdo.pvFaultAddr = pfrm->pvFaultAddr;
smdo.pEP = pfrm->pEP;
smdo.fEPClient = TRUE;
smdo.wszModFullPath[0] = L'\0';
wcscpy(smdo.wszAppFullPath, pfrm->wszExe);
wcscpy(smdo.wszMod, L"unknown");
#ifdef MANIFEST_HEAP
TESTBOOL(hr, InternalGenFullAndTriageMinidumps(hProc, pfrm->pidReqProcess,
wszDump, NULL, &smdo, pfrm->fIs64bit));
#else
TESTBOOL(hr, InternalGenerateMinidump(hProc, pfrm->pidReqProcess, hFile,
&smdo, wszDump));
#endif
if (FAILED(hr))
goto done;
// log an event- don't care if it fails or not.
TESTHR(hr, LogUser(smdo.wszApp, smdo.rgAppVer, smdo.wszMod, smdo.rgModVer,
smdo.pvOffset, pfrm->fIs64bit, ER_USERCRASH_LOG));
// generate all the URLs & file paths we'll need for reporting
TESTHR(hr, BuildManifestURLs(smdo.wszApp, smdo.wszMod, smdo.rgAppVer,
smdo.rgModVer, smdo.pvOffset,
pfrm->fIs64bit, &wszStage1, &wszStage2,
&wszCorpPath, &pbBuf));
if (FAILED(hr))
goto done;
TESTHR(hr, GetVerName(smdo.wszAppFullPath, wszAppName,
sizeofSTRW(wszAppName)));
if (FAILED(hr))
goto done;
wszAppName[sizeofSTRW(wszAppName) - 1] = L'\0';
// we created the wszDump buffer above big enuf to hold both the
// dumpfile path as well as the app compat filename. So make
// use of that right now.
cchSep = wcslen(wszDump);
pwszAppCompat = wszDump + cchSep + 1;
wcscpy(pwszAppCompat, wszDir);
pwszAppCompat[cchDir] = L'\\';
pwszAppCompat[cchDir + 1] = L'\0';
wcscat(pwszAppCompat, c_wszACFileName);
// if we succeed, turn the NULL following the dump file path into
// the DW separator character
TESTBOOL(hr, GetAppCompatData(smdo.wszAppFullPath, smdo.wszAppFullPath,
pwszAppCompat));
if (SUCCEEDED(hr))
wszDump[cchSep] = DW_FILESEP;
ZeroMemory(&dwmb, sizeof(dwmb));
dwmb.wszTitle = wszAppName;
dwmb.nidErrMsg = IDS_FERRMSG;
dwmb.wszStage1 = wszStage1;
dwmb.wszStage2 = wszStage2;
dwmb.wszBrand = c_wszDWBrand;
dwmb.wszFileList = wszDump;
dwmb.hToken = hToken;
dwmb.pvEnv = pvEnv;
dwmb.fIsMSApp = fMSApp;
dwmb.wszCorpPath = wszCorpPath;
if (fShowDebug)
dwmb.dwOptions = emoShowDebugButton;
// check and see if the system is shutting down. If so, CreateProcess is
// gonna pop up some annoying UI that we can't get rid of, so we don't
// want to call it if we know it's gonna happen.
if (GetSystemMetrics(SM_SHUTTINGDOWN))
goto done;
// we get back the name of the manifest file here. it will be up to the client to
// delete it.
frrvRet = StartDWManifest(oCfg, dwmb, wszManifest, fAllowSend);
CopyMemory(ppi, &dwmb.pi, sizeof(PROCESS_INFORMATION));
done:
dw = GetLastError();
if (pbBuf != NULL)
MyFree(pbBuf);
if (hProc != NULL)
CloseHandle(hProc);
#ifndef MANIFEST_HEAP
if (hFile != NULL)
CloseHandle(hFile);
#endif
if (frrvRet != frrvOk)
{
if (wszDump != NULL)
{
if (pwszAppCompat != NULL)
{
wszDump[cchSep] = L'\0';
DeleteFileW(pwszAppCompat);
}
#ifdef MANIFEST_HEAP
DeleteFullAndTriageMiniDumps(wszDump);
#else
DeleteFileW(wszDump);
#endif
}
if (wszManifest != NULL)
DeleteFileW(wszManifest);
}
SetLastError(dw);
return frrvRet;
}
// **************************************************************************
EFaultRepRetVal APIENTRY ReportFault(LPEXCEPTION_POINTERS pep, DWORD dwOpt)
{
USE_TRACING("ReportFault");
CPFFaultClientCfg oCfg;
EFaultRepRetVal frrvRet = frrvErrNoDW;
HRESULT hr = NOERROR;
WCHAR wszFile[MAX_PATH], *pwsz;
DWORD dwFlags = 0;
HKEY hkey = NULL;
BOOL fUseExceptionMode = TRUE, fMSApp = FALSE;
__try
{
VALIDATEPARM(hr, (pep == NULL));
if (FAILED(hr))
goto done;
// get the config info
TESTHR(hr, oCfg.Read(eroPolicyRO));
if (FAILED(hr))
goto done;
// assume system is on a local drive with a base path of "X:\"
if (oCfg.get_TextLog() == eedEnabled)
{
HANDLE hFaultLog = INVALID_HANDLE_VALUE;
GetSystemDirectoryW(wszFile, sizeofSTRW(wszFile));
wszFile[3] = L'\0';
wcscat(wszFile, c_wszLogFileName);
hFaultLog = CreateFileW(wszFile, GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL, OPEN_ALWAYS, 0, NULL);
if (hFaultLog != INVALID_HANDLE_VALUE)
{
SYSTEMTIME st;
DWORD cb, cbWritten;
char szMsg[512];
GetSystemTime(&st);
GetModuleFileNameW(NULL, wszFile, sizeofSTRW(wszFile));
cb = wsprintf(szMsg,
"%02d-%02d-%04d %02d:%02d:%02d User fault %08x in %ls\r\n",
st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute,
st.wSecond, pep->ExceptionRecord->ExceptionCode,
wszFile);
SetFilePointer(hFaultLog, 0, NULL, FILE_END);
WriteFile(hFaultLog, szMsg, cb, &cbWritten, NULL);
CloseHandle(hFaultLog);
}
wszFile[0] = L'\0';
}
// if reporting and notification are both disabled, then there's nothing of
// great value that we're gonna do here, so bail.
// Return frrvErrNoDW to indicate that we didn't do squat
if (oCfg.get_ShowUI() == eedDisabled && oCfg.get_DoReport() == eedDisabled)
goto done;
// if setup is in progress, we want to just bail cuz we don't want to hang
// setup. Also, the network isn't setup so we can't really report anyway.
// At some point, might want to cache this info & report on first launch.
TESTERR(hr, RegOpenKeyExW(HKEY_LOCAL_MACHINE, c_wszRKSetup, 0, KEY_READ,
&hkey));
if (SUCCEEDED(hr))
{
DWORD cbData;
DWORD dwData;
cbData = sizeof(dwData);
dwData = 0;
TESTERR(hr, RegQueryValueExW(hkey, c_wszRVSetupNow, NULL, NULL,
(LPBYTE)&dwData, &cbData));
RegCloseKey(hkey);
if (SUCCEEDED(hr) && dwData != 0)
goto done;
}
if (oCfg.get_ShowUI() == eedDisabled)
{
LPCWSTR wszULPath = oCfg.get_DumpPath(NULL, 0);
fUseExceptionMode = TRUE;
dwFlags |= fDwHeadless;
// check and make sure that we have a corporate path specified. If
// we don't, bail
if (wszULPath == NULL || *wszULPath == L'\0')
goto done;
}
// don't want to go into this if we're already in the middle of reporting
if (g_fAlreadyReportingFault)
goto done;
g_fAlreadyReportingFault = TRUE;
// make sure we're not trying to report for DW or dumprep-
GetModuleFileNameW(NULL, wszFile, sizeofSTRW(wszFile));
for(pwsz = wszFile + wcslen(wszFile);
pwsz >= wszFile && *pwsz != L'\\';
pwsz--);
if (*pwsz == L'\\')
pwsz++;
if (_wcsicmp(pwsz, L"dwwin.exe") == 0 ||
_wcsicmp(pwsz, L"dumprep.exe") == 0)
goto done;
// figure out how we're reporting / notifying the user
if (oCfg.get_DoReport() == eedDisabled ||
oCfg.ShouldCollect(wszFile, &fMSApp) == FALSE)
dwFlags |= fDwNoReporting;
// if it's a MS app, set the flag that says we can have 'please help
// Microsoft' text in DW.
if (fMSApp == FALSE)
dwFlags |= fDwUseLitePlea;
// if we're not headless, then we have to see if we have the correct
// security context to launch DW directly. The correct security context
// is defined as the current process having the same security context as
// the user currently logged on interactively to the current session
if (oCfg.get_ShowUI() != eedDisabled)
{
if (oCfg.get_ForceQueueMode())
{
fUseExceptionMode = FALSE;
}
else
{
fUseExceptionMode = DoUserContextsMatch();
if (fUseExceptionMode == FALSE)
fUseExceptionMode = DoWinstaDesktopMatch() &&
(AmIPrivileged(FALSE) == FALSE);
}
}
// if we can use exception mode, then just go ahead and use the normal
// reporting mechanism (shared memory block, etc)
if (fUseExceptionMode)
{
LPCWSTR pwszServer = oCfg.get_DefaultServer(NULL, 0);
LPCSTR szServer;
char szBuf[MAX_PATH];
// determine what server we're going to send the data to.
szBuf[0] = '\0';
if (pwszServer != NULL && *pwszServer != L'\0')
WideCharToMultiByte(CP_ACP, 0, pwszServer, -1, szBuf,
sizeof(szBuf), NULL, NULL);
if (szBuf[0] != '\0')
szServer = szBuf;
else
szServer = (oCfg.get_UseInternal() == 1) ? c_szDWDefServerI :
c_szDWDefServerE;
frrvRet = StartDWException(pep, dwOpt, dwFlags, szServer, -1);
}
// otherwise, have to use manifest, which of course means generating the
// minidump ourselves, parsing it for the signature, and everything else
// that DW does automatically for us... Sigh...
else
{
frrvRet = StartManifestReport(pep, wszFile, dwOpt, -1);
}
}
__except(SetLastError(GetExceptionCode()), EXCEPTION_EXECUTE_HANDLER)
{
}
done:
g_fAlreadyReportingFault = FALSE;
return frrvRet;
}
Reference in a new issue Copy permalink