/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ /* system headers */ #include "system.h" #include #include "file_url.h" #include "path_helper.hxx" #include #include #include #ifndef __MINGW32__ #include #endif #include #include typedef struct _oslSignalHandlerImpl { oslSignalHandlerFunction Handler; void* pData; struct _oslSignalHandlerImpl* pNext; } oslSignalHandlerImpl; static sal_Bool bErrorReportingEnabled = sal_True; static sal_Bool bInitSignal = sal_False; static oslMutex SignalListMutex; static oslSignalHandlerImpl* SignalList; static long WINAPI SignalHandlerFunction(LPEXCEPTION_POINTERS lpEP); static sal_Bool InitSignal(void) { HMODULE hFaultRep; SignalListMutex = osl_createMutex(); SetUnhandledExceptionFilter(SignalHandlerFunction); hFaultRep = LoadLibrary( "faultrep.dll" ); if ( hFaultRep ) { #ifdef __MINGW32__ typedef BOOL (WINAPI *pfn_ADDEREXCLUDEDAPPLICATIONW)(LPCWSTR); #endif pfn_ADDEREXCLUDEDAPPLICATIONW pfn = (pfn_ADDEREXCLUDEDAPPLICATIONW)GetProcAddress( hFaultRep, "AddERExcludedApplicationW" ); if ( pfn ) pfn( L"SOFFICE.EXE" ); FreeLibrary( hFaultRep ); } return sal_True; } static sal_Bool DeInitSignal(void) { SetUnhandledExceptionFilter(NULL); osl_destroyMutex(SignalListMutex); return sal_False; } static oslSignalAction CallSignalHandler(oslSignalInfo *pInfo) { oslSignalHandlerImpl* pHandler = SignalList; oslSignalAction Action = osl_Signal_ActCallNextHdl; while (pHandler != NULL) { if ((Action = pHandler->Handler(pHandler->pData, pInfo)) != osl_Signal_ActCallNextHdl) break; pHandler = pHandler->pNext; } return Action; } /*****************************************************************************/ /* SignalHandlerFunction */ /*****************************************************************************/ #define REPORTENV_PARAM "-crashreportenv:" #define REPORTENV_PARAM2 "/crashreportenv:" static BOOL ReportCrash( LPEXCEPTION_POINTERS lpEP ) { BOOL fSuccess = FALSE; BOOL fAutoReport = FALSE; TCHAR szBuffer[1024]; ::osl::LongPathBuffer< sal_Char > aPath( MAX_LONG_PATH ); LPTSTR lpFilePart; PROCESS_INFORMATION ProcessInfo; STARTUPINFO StartupInfo; int argi; if ( !bErrorReportingEnabled ) return FALSE; /* Check if crash reporter was disabled by command line */ for ( argi = 1; argi < __argc; argi++ ) { if ( 0 == stricmp( __argv[argi], "-nocrashreport" ) || 0 == stricmp( __argv[argi], "/nocrashreport" ) ) return FALSE; else if ( 0 == stricmp( __argv[argi], "-autocrashreport" ) || 0 == stricmp( __argv[argi], "/autocrashreport" ) ) fAutoReport = TRUE; else if ( 0 == strnicmp( __argv[argi], REPORTENV_PARAM, strlen(REPORTENV_PARAM) ) || 0 == strnicmp( __argv[argi], REPORTENV_PARAM2, strlen(REPORTENV_PARAM2) ) ) { const char *envparam = __argv[argi] + strlen(REPORTENV_PARAM); const char *delim = strchr(envparam, '=' ); if ( delim ) { CHAR *lpVariable; CHAR *lpValue; const char *variable = envparam; size_t variable_len = delim - envparam; const char *value = delim + 1; size_t value_len = strlen(envparam) - variable_len - 1; if ( '\"' == *value ) { const char *quote; value++; value_len--; quote = strchr( value, '\"' ); if ( quote ) value_len = quote - value; } lpVariable = reinterpret_cast< CHAR* >( _alloca( variable_len + 1 ) ); memcpy( lpVariable, variable, variable_len ); lpVariable[variable_len] = 0; lpValue = reinterpret_cast< CHAR* >( _alloca( value_len + 1) ); memcpy( lpValue, value, value_len ); lpValue[value_len] = 0; SetEnvironmentVariable( lpVariable, lpValue ); } } } if ( SearchPath( NULL, TEXT( "crashrep.exe" ), NULL, aPath.getBufSizeInSymbols(), aPath, &lpFilePart ) ) { ZeroMemory( &StartupInfo, sizeof(StartupInfo) ); StartupInfo.cb = sizeof(StartupInfo.cb); sntprintf( szBuffer, elementsof(szBuffer), _T("%s -p %u -excp 0x%p -t %u%s"), static_cast( aPath ), GetCurrentProcessId(), lpEP, GetCurrentThreadId(), fAutoReport ? _T(" -noui -send") : _T(" -noui") ); if ( CreateProcess( NULL, szBuffer, NULL, NULL, FALSE, #ifdef UNICODE CREATE_UNICODE_ENVIRONMENT, #else 0, #endif NULL, NULL, &StartupInfo, &ProcessInfo ) ) { DWORD dwExitCode; WaitForSingleObject( ProcessInfo.hProcess, INFINITE ); if ( GetExitCodeProcess( ProcessInfo.hProcess, &dwExitCode ) && 0 == dwExitCode ) fSuccess = TRUE; } } return fSuccess; } /*****************************************************************************/ /* SignalHandlerFunction */ /*****************************************************************************/ static BOOL WINAPI IsWin95A(void) { OSVERSIONINFO ovi; ZeroMemory( &ovi, sizeof(ovi) ); ovi.dwOSVersionInfoSize = sizeof(ovi); if ( GetVersionEx( &ovi ) ) /* See MSDN January 2000 documentation of GetVersionEx */ return (ovi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && (ovi.dwMajorVersion <= 4) && (ovi.dwMinorVersion == 0) && (ovi.dwBuildNumber == 0x040003B6); /* Something wrent wrong. So assume we have an older operating prior Win95 */ return TRUE; } /* magic Microsoft C++ compiler exception constant */ #define EXCEPTION_MSC_CPP_EXCEPTION 0xe06d7363 static long WINAPI SignalHandlerFunction(LPEXCEPTION_POINTERS lpEP) { static sal_Bool bNested = sal_False; sal_Bool bRaiseCrashReporter = sal_False; oslSignalInfo Info; oslSignalAction Action; Info.UserSignal = lpEP->ExceptionRecord->ExceptionCode; Info.UserData = NULL; switch (lpEP->ExceptionRecord->ExceptionCode) { /* Transform unhandled exceptions into access violations. Microsoft C++ compiler (add more for other compilers if necessary). */ case EXCEPTION_MSC_CPP_EXCEPTION: case EXCEPTION_ACCESS_VIOLATION: Info.Signal = osl_Signal_AccessViolation; bRaiseCrashReporter = sal_True; break; case EXCEPTION_INT_DIVIDE_BY_ZERO: Info.Signal = osl_Signal_IntegerDivideByZero; bRaiseCrashReporter = sal_True; break; case EXCEPTION_FLT_DIVIDE_BY_ZERO: Info.Signal = osl_Signal_FloatDivideByZero; bRaiseCrashReporter = sal_True; break; case EXCEPTION_BREAKPOINT: Info.Signal = osl_Signal_DebugBreak; break; default: Info.Signal = osl_Signal_System; bRaiseCrashReporter = sal_True; break; } if ( !bNested ) { bNested = sal_True; if ( bRaiseCrashReporter && ReportCrash( lpEP ) || IsWin95A() ) { CallSignalHandler(&Info); Action = osl_Signal_ActKillApp; } else Action = CallSignalHandler(&Info); } else Action = osl_Signal_ActKillApp; switch ( Action ) { case osl_Signal_ActCallNextHdl: return (EXCEPTION_CONTINUE_SEARCH); case osl_Signal_ActAbortApp: return (EXCEPTION_EXECUTE_HANDLER); case osl_Signal_ActKillApp: SetErrorMode(SEM_NOGPFAULTERRORBOX); exit(255); break; default: break; } return (EXCEPTION_CONTINUE_EXECUTION); } /*****************************************************************************/ /* osl_addSignalHandler */ /*****************************************************************************/ oslSignalHandler SAL_CALL osl_addSignalHandler(oslSignalHandlerFunction Handler, void* pData) { oslSignalHandlerImpl* pHandler; OSL_ASSERT(Handler != NULL); if (! bInitSignal) bInitSignal = InitSignal(); pHandler = reinterpret_cast< oslSignalHandlerImpl* >( calloc( 1, sizeof(oslSignalHandlerImpl) ) ); if (pHandler != NULL) { pHandler->Handler = Handler; pHandler->pData = pData; osl_acquireMutex(SignalListMutex); pHandler->pNext = SignalList; SignalList = pHandler; osl_releaseMutex(SignalListMutex); return (pHandler); } return (NULL); } /*****************************************************************************/ /* osl_removeSignalHandler */ /*****************************************************************************/ sal_Bool SAL_CALL osl_removeSignalHandler(oslSignalHandler Handler) { oslSignalHandlerImpl *pHandler, *pPrevious = NULL; OSL_ASSERT(Handler != NULL); if (! bInitSignal) bInitSignal = InitSignal(); osl_acquireMutex(SignalListMutex); pHandler = SignalList; while (pHandler != NULL) { if (pHandler == Handler) { if (pPrevious) pPrevious->pNext = pHandler->pNext; else SignalList = pHandler->pNext; osl_releaseMutex(SignalListMutex); if (SignalList == NULL) bInitSignal = DeInitSignal(); free(pHandler); return (sal_True); } pPrevious = pHandler; pHandler = pHandler->pNext; } osl_releaseMutex(SignalListMutex); return (sal_False); } /*****************************************************************************/ /* osl_raiseSignal */ /*****************************************************************************/ oslSignalAction SAL_CALL osl_raiseSignal(sal_Int32 UserSignal, void* UserData) { oslSignalInfo Info; oslSignalAction Action; if (! bInitSignal) bInitSignal = InitSignal(); osl_acquireMutex(SignalListMutex); Info.Signal = osl_Signal_User; Info.UserSignal = UserSignal; Info.UserData = UserData; Action = CallSignalHandler(&Info); osl_releaseMutex(SignalListMutex); return (Action); } /*****************************************************************************/ /* osl_setErrorReporting */ /*****************************************************************************/ sal_Bool SAL_CALL osl_setErrorReporting( sal_Bool bEnable ) { sal_Bool bOld = bErrorReportingEnabled; bErrorReportingEnabled = bEnable; return bOld; }