__declspec(noreturn) void __cdecl __raise_securityfailure( PEXCEPTION_POINTERS const exception_pointers ) { #ifdef _VCRT_BUILD DebuggerWasPresent = IsDebuggerPresent(); _CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_GSFAILURE); #endif // _VCRT_BUILD SetUnhandledExceptionFilter(NULL); UnhandledExceptionFilter(exception_pointers); #ifdef _VCRT_BUILD // If we make it back from Watson, then the user may have asked to debug // the app. If we weren't under a debugger before invoking Watson, // re-signal the VS CRT debugger hook, so a newly attached debugger gets // a chance to break into the process. if (!DebuggerWasPresent) { _CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_GSFAILURE); } #endif // _VCRT_BUILD TerminateProcess(GetCurrentProcess(), STATUS_SECURITY_CHECK_FAILURE); }
__inline DWORD WINAPI OrpcBreakpointFilter( LPEXCEPTION_POINTERS lpExcptPtr, BOOL *lpAeDebugAttached ) \ { BOOL fAeDebugAttached = FALSE; DWORD dwRet; if ( lpExcptPtr->ExceptionRecord->ExceptionCode == EXCEPTION_ORPC_DEBUG ) { if ( UnhandledExceptionFilter(lpExcptPtr) == EXCEPTION_CONTINUE_SEARCH ) { // It is important that we don't return EXCEPTION_CONTINUE_SEARCH. // This is because there might an handler up the stack which could // handle this exception. Just set the flag indicating that a // debugger is now attached. fAeDebugAttached = TRUE; } dwRet = EXCEPTION_EXECUTE_HANDLER; } else { // Not one of our exceptions. dwRet = EXCEPTION_CONTINUE_SEARCH; } if ( lpAeDebugAttached != NULL ) (*lpAeDebugAttached) = fAeDebugAttached; return dwRet; }
unsigned long CrashFilter(LPEXCEPTION_POINTERS pException, int exceptionCode) { unsigned long result; if ((result = UnhandledExceptionFilter(pException)) != EXCEPTION_EXECUTE_HANDLER) { return result; } else if (avmthane::show_error) { // if -error option dont do a dump return EXCEPTION_CONTINUE_SEARCH; } AvmLog("avmplus crash: exception 0x%08lX occurred\n", exceptionCode); typedef BOOL (WINAPI *MINIDUMP_WRITE_DUMP)( HANDLE hProcess, DWORD ProcessId, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam ); HMODULE hDbgHelp = LoadLibrary("dbghelp.dll"); MINIDUMP_WRITE_DUMP MiniDumpWriteDump_ = (MINIDUMP_WRITE_DUMP)GetProcAddress(hDbgHelp, "MiniDumpWriteDump"); if (MiniDumpWriteDump_) { MINIDUMP_EXCEPTION_INFORMATION M; const char DumpPath[] = "avmplusCrash.dmp"; M.ThreadId = GetCurrentThreadId(); M.ExceptionPointers = pException; M.ClientPointers = 0; AvmLog("Writing minidump crash log to %s\n", DumpPath); HANDLE hDumpFile = CreateFile(DumpPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); MiniDumpWriteDump_(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpNormal, (pException) ? &M : NULL, NULL, NULL); CloseHandle(hDumpFile); } else { AvmLog("minidump not available, no crash log written.\n"); } return result; }
LONG __stdcall myExceptFilterProc( LPEXCEPTION_POINTERS param ) { if (IsDebuggerPresent()) { return UnhandledExceptionFilter(param); } else { //DumpCrashInfo( param ); TerminateProcess( GetCurrentProcess(), 0 ); return 0;// never reached } }
__declspec(noreturn) void __cdecl __report_gsfailure (ULONG_PTR StackCookie) { volatile UINT_PTR cookie[2] __MINGW_ATTRIB_UNUSED; #if defined(_WIN64) && !defined(__aarch64__) ULONG64 controlPC, imgBase, establisherFrame; PRUNTIME_FUNCTION fctEntry; PVOID hndData; RtlCaptureContext (&GS_ContextRecord); controlPC = GS_ContextRecord.Rip; fctEntry = RtlLookupFunctionEntry (controlPC, &imgBase, NULL); if (fctEntry != NULL) { RtlVirtualUnwind (UNW_FLAG_NHANDLER, imgBase, controlPC, fctEntry, &GS_ContextRecord, &hndData, &establisherFrame, NULL); } else #endif /* _WIN64 */ { #if defined(__x86_64__) || defined(_AMD64_) GS_ContextRecord.Rip = (ULONGLONG) _ReturnAddress(); GS_ContextRecord.Rsp = (ULONGLONG) _AddressOfReturnAddress() + 8; #elif defined(__i386__) || defined(_X86_) GS_ContextRecord.Eip = (DWORD) _ReturnAddress(); GS_ContextRecord.Esp = (DWORD) _AddressOfReturnAddress() + 4; #elif defined(__arm__) || defined(_ARM_) GS_ContextRecord.Pc = (DWORD) _ReturnAddress(); GS_ContextRecord.Sp = (DWORD) _AddressOfReturnAddress() + 4; #endif /* _WIN64 */ } #if defined(__x86_64__) || defined(_AMD64_) GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Rip; GS_ContextRecord.Rcx = StackCookie; #elif defined(__i386__) || defined(_X86_) GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Eip; GS_ContextRecord.Ecx = StackCookie; #elif defined(__arm__) || defined(_ARM_) GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Pc; UNUSED_PARAM(StackCookie); #endif /* _WIN64 */ GS_ExceptionRecord.ExceptionCode = STATUS_STACK_BUFFER_OVERRUN; GS_ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE; cookie[0] = __security_cookie; cookie[1] = __security_cookie_complement; SetUnhandledExceptionFilter (NULL); UnhandledExceptionFilter ((EXCEPTION_POINTERS *) &GS_ExceptionPointers); TerminateProcess (GetCurrentProcess (), STATUS_STACK_BUFFER_OVERRUN); abort(); }
/* FUNCTIONS *****************************************************************/ static LONG BaseThreadExceptionFilter(EXCEPTION_POINTERS * ExceptionInfo) { LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER; if (GlobalTopLevelExceptionFilter != NULL) { _SEH2_TRY { ExceptionDisposition = GlobalTopLevelExceptionFilter(ExceptionInfo); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo); } _SEH2_END; }
static LONG BaseThreadExceptionFilter(EXCEPTION_POINTERS * ExceptionInfo) { LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER; LPTOP_LEVEL_EXCEPTION_FILTER RealFilter; RealFilter = RtlDecodePointer(GlobalTopLevelExceptionFilter); if (RealFilter != NULL) { _SEH2_TRY { ExceptionDisposition = RealFilter(ExceptionInfo); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo); } _SEH2_END; }
int __cdecl _XcptFilter ( unsigned long xcptnum, PEXCEPTION_POINTERS pxcptinfoptrs ) { struct _XCPT_ACTION * pxcptact; _PHNDLR phandler; void *oldpxcptinfoptrs; int oldfpecode; int indx; _ptiddata ptd = _getptd_noexit(); if (!ptd) { // we can't deal with it - pass it on. return( UnhandledExceptionFilter(pxcptinfoptrs) ); } pxcptact = xcptlookup(xcptnum, ptd->_pxcptacttab); if (pxcptact == NULL) { phandler = SIG_DFL; } else { phandler = pxcptact->XcptAction; } /* * first, take care of all unrecognized exceptions and exceptions with * XcptAction values of SIG_DFL. */ if ( phandler == SIG_DFL ) /* * pass the buck to the UnhandledExceptionFilter */ return( UnhandledExceptionFilter(pxcptinfoptrs) ); /* * next, weed out all of the exceptions that need to be handled by * dying, perhaps with a runtime error message */ if ( phandler == SIG_DIE ) { /* * reset XcptAction (in case of recursion) and drop into the * except-clause. */ pxcptact->XcptAction = SIG_DFL; return(EXCEPTION_EXECUTE_HANDLER); } /* * next, weed out all of the exceptions that are simply ignored */ if ( phandler == SIG_IGN ) /* * resume execution */ return(EXCEPTION_CONTINUE_EXECUTION); /* * the remaining exceptions all correspond to C signals which have * signal handlers associated with them. for some, special setup * is required before the signal handler is called. in all cases, * if the signal handler returns, -1 is returned by this function * to resume execution at the point where the exception occurred. */ /* * save the old value of _pxcptinfoptrs (in case this is a nested * exception/signal) and store the current one. */ oldpxcptinfoptrs = PXCPTINFOPTRS; PXCPTINFOPTRS = pxcptinfoptrs; /* * call the user-supplied signal handler * * floating point exceptions must be handled specially since, from * the C point-of-view, there is only one signal. the exact identity * of the exception is passed in the global variable _fpecode. */ if ( pxcptact->SigNum == SIGFPE ) { /* * reset the XcptAction field to the default for all entries * corresponding to SIGFPE. */ for ( indx = _First_FPE_Indx ; indx < _First_FPE_Indx + _Num_FPE ; indx++ ) { ( (struct _XCPT_ACTION *)(ptd->_pxcptacttab) + indx )->XcptAction = SIG_DFL; } /* * Save the current _fpecode in case it is a nested floating * point exception (not clear that we need to support this, * but it's easy). */ oldfpecode = FPECODE; /* * there are no exceptions corresponding to * following _FPE_xxx codes: * * _FPE_UNEMULATED * _FPE_SQRTNEG * * futhermore, STATUS_FLOATING_STACK_CHECK is * raised for both floating point stack under- * flow and overflow. thus, the exception does * not distinguish between _FPE_STACKOVERLOW * and _FPE_STACKUNDERFLOW. arbitrarily, _fpecode * is set to the former value. * * the following should be a switch statement but, alas, the * compiler doesn't like switching on unsigned longs... */ if ( pxcptact->XcptNum == STATUS_FLOAT_DIVIDE_BY_ZERO ) FPECODE = _FPE_ZERODIVIDE; else if ( pxcptact->XcptNum == STATUS_FLOAT_INVALID_OPERATION ) FPECODE = _FPE_INVALID; else if ( pxcptact->XcptNum == STATUS_FLOAT_OVERFLOW ) FPECODE = _FPE_OVERFLOW; else if ( pxcptact->XcptNum == STATUS_FLOAT_UNDERFLOW ) FPECODE = _FPE_UNDERFLOW; else if ( pxcptact->XcptNum == STATUS_FLOAT_DENORMAL_OPERAND ) FPECODE = _FPE_DENORMAL; else if ( pxcptact->XcptNum == STATUS_FLOAT_INEXACT_RESULT ) FPECODE = _FPE_INEXACT; else if ( pxcptact->XcptNum == STATUS_FLOAT_STACK_CHECK ) FPECODE = _FPE_STACKOVERFLOW; /* * call the SIGFPE handler. note the special code to support * old MS-C programs whose SIGFPE handlers expect two args. * * NOTE: THE CAST AND CALL BELOW DEPEND ON __cdecl BEING * CALLER CLEANUP! */ (*(void (__cdecl *)(int, int))phandler)(SIGFPE, FPECODE); /* * restore the old value of _fpecode */ FPECODE = oldfpecode; } else { /* * reset the XcptAction field to the default, then call the * user-supplied handler */ pxcptact->XcptAction = SIG_DFL; (*phandler)(pxcptact->SigNum); } /* * restore the old value of _pxcptinfoptrs */ PXCPTINFOPTRS = oldpxcptinfoptrs; return(EXCEPTION_CONTINUE_EXECUTION); }
_CRTIMP void __cdecl _invoke_watson( const wchar_t *pszExpression, const wchar_t *pszFunction, const wchar_t *pszFile, unsigned int nLine, uintptr_t pReserved ) { /* Fake an exception to call reportfault. */ EXCEPTION_RECORD ExceptionRecord; CONTEXT ContextRecord; EXCEPTION_POINTERS ExceptionPointers; BOOL wasDebuggerPresent = FALSE; DWORD ret = 0; (pszExpression); (pszFunction); (pszFile); (nLine); (pReserved); #ifdef _X86_ __asm { mov dword ptr [ContextRecord.Eax], eax mov dword ptr [ContextRecord.Ecx], ecx mov dword ptr [ContextRecord.Edx], edx mov dword ptr [ContextRecord.Ebx], ebx mov dword ptr [ContextRecord.Esi], esi mov dword ptr [ContextRecord.Edi], edi mov word ptr [ContextRecord.SegSs], ss mov word ptr [ContextRecord.SegCs], cs mov word ptr [ContextRecord.SegDs], ds mov word ptr [ContextRecord.SegEs], es mov word ptr [ContextRecord.SegFs], fs mov word ptr [ContextRecord.SegGs], gs pushfd pop [ContextRecord.EFlags] } ContextRecord.ContextFlags = CONTEXT_CONTROL; #pragma warning(push) #pragma warning(disable:4311) ContextRecord.Eip = (ULONG)_ReturnAddress(); ContextRecord.Esp = (ULONG)_AddressOfReturnAddress(); #pragma warning(pop) ContextRecord.Ebp = *((ULONG *)_AddressOfReturnAddress()-1); #elif defined (_IA64_) || defined (_AMD64_) /* Need to fill up the Context in IA64 and AMD64. */ RtlCaptureContext(&ContextRecord); #else /* defined (_IA64_) || defined (_AMD64_) */ ZeroMemory(&ContextRecord, sizeof(ContextRecord)); #endif /* defined (_IA64_) || defined (_AMD64_) */ ZeroMemory(&ExceptionRecord, sizeof(ExceptionRecord)); ExceptionRecord.ExceptionCode = STATUS_INVALID_PARAMETER; ExceptionRecord.ExceptionAddress = _ReturnAddress(); ExceptionPointers.ExceptionRecord = &ExceptionRecord; ExceptionPointers.ContextRecord = &ContextRecord; wasDebuggerPresent = IsDebuggerPresent(); /* Make sure any filter already in place is deleted. */ SetUnhandledExceptionFilter(NULL); ret = UnhandledExceptionFilter(&ExceptionPointers); // if no handler found and no debugger previously attached // the execution must stop into the debugger hook. if (ret == EXCEPTION_CONTINUE_SEARCH && !wasDebuggerPresent) { _CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_INVALIDPARAMETER); } TerminateProcess(GetCurrentProcess(), STATUS_INVALID_PARAMETER); }