/* * Win32 exception functions * * Copyright (c) 1996 Onno Hovers, (onno@stack.urc.tue.nl) * Copyright (c) 1999 Alexandre Julliard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * Notes: * What really happens behind the scenes of those new * __try{...}__except(..){....} and * __try{...}__finally{...} * statements is simply not documented by Microsoft. There could be different * reasons for this: * One reason could be that they try to hide the fact that exception * handling in Win32 looks almost the same as in OS/2 2.x. * Another reason could be that Microsoft does not want others to write * binary compatible implementations of the Win32 API (like us). * * Whatever the reason, THIS SUCKS!! Ensuring portability or future * compatibility may be valid reasons to keep some things undocumented. * But exception handling is so basic to Win32 that it should be * documented! * */ #include "config.h" #include "wine/port.h" #include #include #include "ntstatus.h" #define WIN32_NO_STATUS #include "windef.h" #include "winbase.h" #include "winerror.h" #include "winternl.h" #include "wingdi.h" #include "winuser.h" #include "wine/exception.h" #include "wine/library.h" #include "excpt.h" #include "wine/unicode.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(seh); static PTOP_LEVEL_EXCEPTION_FILTER top_filter; typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT); typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT); /******************************************************************* * RaiseException (KERNEL32.@) */ void WINAPI RaiseException( DWORD code, DWORD flags, DWORD nbargs, const ULONG_PTR *args ) { EXCEPTION_RECORD record; /* Compose an exception record */ record.ExceptionCode = code; record.ExceptionFlags = flags & EH_NONCONTINUABLE; record.ExceptionRecord = NULL; record.ExceptionAddress = RaiseException; if (nbargs && args) { if (nbargs > EXCEPTION_MAXIMUM_PARAMETERS) nbargs = EXCEPTION_MAXIMUM_PARAMETERS; record.NumberParameters = nbargs; memcpy( record.ExceptionInformation, args, nbargs * sizeof(*args) ); } else record.NumberParameters = 0; RtlRaiseException( &record ); } /******************************************************************* * format_exception_msg */ static int format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, int size ) { const EXCEPTION_RECORD *rec = ptr->ExceptionRecord; int len,len2; switch(rec->ExceptionCode) { case EXCEPTION_INT_DIVIDE_BY_ZERO: len = snprintf( buffer, size, "Unhandled division by zero" ); break; case EXCEPTION_INT_OVERFLOW: len = snprintf( buffer, size, "Unhandled overflow" ); break; case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: len = snprintf( buffer, size, "Unhandled array bounds" ); break; case EXCEPTION_ILLEGAL_INSTRUCTION: len = snprintf( buffer, size, "Unhandled illegal instruction" ); break; case EXCEPTION_STACK_OVERFLOW: len = snprintf( buffer, size, "Unhandled stack overflow" ); break; case EXCEPTION_PRIV_INSTRUCTION: len = snprintf( buffer, size, "Unhandled privileged instruction" ); break; case EXCEPTION_ACCESS_VIOLATION: if (rec->NumberParameters == 2) len = snprintf( buffer, size, "Unhandled page fault on %s access to 0x%08lx", rec->ExceptionInformation[0] ? "write" : "read", rec->ExceptionInformation[1]); else len = snprintf( buffer, size, "Unhandled page fault"); break; case EXCEPTION_DATATYPE_MISALIGNMENT: len = snprintf( buffer, size, "Unhandled alignment" ); break; case CONTROL_C_EXIT: len = snprintf( buffer, size, "Unhandled ^C"); break; case STATUS_POSSIBLE_DEADLOCK: len = snprintf( buffer, size, "Critical section %08lx wait failed", rec->ExceptionInformation[0]); break; case EXCEPTION_WINE_STUB: if (HIWORD(rec->ExceptionInformation[1])) len = snprintf( buffer, size, "Unimplemented function %s.%s called", (char *)rec->ExceptionInformation[0], (char *)rec->ExceptionInformation[1] ); else len = snprintf( buffer, size, "Unimplemented function %s.%ld called", (char *)rec->ExceptionInformation[0], rec->ExceptionInformation[1] ); break; case EXCEPTION_WINE_ASSERTION: len = snprintf( buffer, size, "Assertion failed" ); break; case EXCEPTION_VM86_INTx: len = snprintf( buffer, size, "Unhandled interrupt %02lx in vm86 mode", rec->ExceptionInformation[0]); break; case EXCEPTION_VM86_STI: len = snprintf( buffer, size, "Unhandled sti in vm86 mode"); break; case EXCEPTION_VM86_PICRETURN: len = snprintf( buffer, size, "Unhandled PIC return in vm86 mode"); break; default: len = snprintf( buffer, size, "Unhandled exception 0x%08lx", rec->ExceptionCode); break; } if ((len<0) || (len>=size)) return -1; #ifdef __i386__ if (ptr->ContextRecord->SegCs != wine_get_cs()) len2 = snprintf(buffer+len, size-len, " at address 0x%04lx:0x%08lx", ptr->ContextRecord->SegCs, (DWORD)ptr->ExceptionRecord->ExceptionAddress); else #endif len2 = snprintf(buffer+len, size-len, " at address %p", ptr->ExceptionRecord->ExceptionAddress); if ((len2<0) || (len>=size-len)) return -1; return len+len2; } /****************************************************************** * start_debugger * * Does the effective debugger startup according to 'format' */ static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent) { OBJECT_ATTRIBUTES attr; UNICODE_STRING nameW; char *cmdline, *env, *p; HANDLE hDbgConf; DWORD bAuto = FALSE; PROCESS_INFORMATION info; STARTUPINFOA startup; char* format = NULL; BOOL ret = FALSE; char buffer[256]; static const WCHAR AeDebugW[] = {'M','a','c','h','i','n','e','\\', 'S','o','f','t','w','a','r','e','\\', 'M','i','c','r','o','s','o','f','t','\\', 'W','i','n','d','o','w','s',' ','N','T','\\', 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', 'A','e','D','e','b','u','g',0}; static const WCHAR DebuggerW[] = {'D','e','b','u','g','g','e','r',0}; static const WCHAR AutoW[] = {'A','u','t','o',0}; format_exception_msg( epointers, buffer, sizeof(buffer) ); MESSAGE("wine: %s (thread %04lx), starting debugger...\n", buffer, GetCurrentThreadId()); attr.Length = sizeof(attr); attr.RootDirectory = 0; attr.ObjectName = &nameW; attr.Attributes = 0; attr.SecurityDescriptor = NULL; attr.SecurityQualityOfService = NULL; RtlInitUnicodeString( &nameW, AeDebugW ); if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr )) { char buffer[64]; KEY_VALUE_PARTIAL_INFORMATION *info; DWORD format_size = 0; RtlInitUnicodeString( &nameW, DebuggerW ); if (NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation, NULL, 0, &format_size ) == STATUS_BUFFER_OVERFLOW) { char *data = HeapAlloc(GetProcessHeap(), 0, format_size); NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation, data, format_size, &format_size ); info = (KEY_VALUE_PARTIAL_INFORMATION *)data; RtlUnicodeToMultiByteSize( &format_size, (WCHAR *)info->Data, info->DataLength ); format = HeapAlloc( GetProcessHeap(), 0, format_size+1 ); RtlUnicodeToMultiByteN( format, format_size, NULL, (WCHAR *)info->Data, info->DataLength ); format[format_size] = 0; if (info->Type == REG_EXPAND_SZ) { char* tmp; /* Expand environment variable references */ format_size=ExpandEnvironmentStringsA(format,NULL,0); tmp=HeapAlloc(GetProcessHeap(), 0, format_size); ExpandEnvironmentStringsA(format,tmp,format_size); HeapFree(GetProcessHeap(), 0, format); format=tmp; } HeapFree( GetProcessHeap(), 0, data ); } RtlInitUnicodeString( &nameW, AutoW ); if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer)-sizeof(WCHAR), &format_size )) { info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer; if (info->Type == REG_DWORD) memcpy( &bAuto, info->Data, sizeof(DWORD) ); else if (info->Type == REG_SZ) { WCHAR *str = (WCHAR *)info->Data; str[info->DataLength/sizeof(WCHAR)] = 0; bAuto = atoiW( str ); } } else bAuto = TRUE; NtClose(hDbgConf); } if (format) { cmdline = HeapAlloc(GetProcessHeap(), 0, strlen(format) + 2*20); sprintf(cmdline, format, GetCurrentProcessId(), hEvent); HeapFree(GetProcessHeap(), 0, format); } else { cmdline = HeapAlloc(GetProcessHeap(), 0, 80); sprintf(cmdline, "winedbg --auto %ld %ld", GetCurrentProcessId(), (ULONG_PTR)hEvent); } if (!bAuto) { HMODULE mod = GetModuleHandleA( "user32.dll" ); MessageBoxA_funcptr pMessageBoxA = NULL; if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" ); if (pMessageBoxA) { static const char msg[] = ".\nDo you wish to debug it?"; char buffer[256]; format_exception_msg( epointers, buffer, sizeof(buffer)-sizeof(msg) ); strcat( buffer, msg ); if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO) { TRACE("Killing process\n"); goto EXIT; } } } /* make WINEDEBUG empty in the environment */ env = GetEnvironmentStringsA(); for (p = env; *p; p += strlen(p) + 1) { if (!memcmp( p, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 )) { char *next = p + strlen(p); char *end = next + 1; while (*end) end += strlen(end) + 1; memmove( p + sizeof("WINEDEBUG=") - 1, next, end + 1 - next ); break; } } TRACE("Starting debugger %s\n", debugstr_a(cmdline)); memset(&startup, 0, sizeof(startup)); startup.cb = sizeof(startup); startup.dwFlags = STARTF_USESHOWWINDOW; startup.wShowWindow = SW_SHOWNORMAL; ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info); FreeEnvironmentStringsA( env ); if (ret) WaitForSingleObject(hEvent, INFINITE); /* wait for debugger to come up... */ else ERR("Couldn't start debugger (%s) (%ld)\n" "Read the Wine Developers Guide on how to set up winedbg or another debugger\n", debugstr_a(cmdline), GetLastError()); EXIT: HeapFree(GetProcessHeap(), 0, cmdline); return ret; } /****************************************************************** * start_debugger_atomic * * starts the debugger in an atomic way: * - either the debugger is not started and it is started * - or the debugger has already been started by another thread * - or the debugger couldn't be started * * returns TRUE for the two first conditions, FALSE for the last */ static int start_debugger_atomic(PEXCEPTION_POINTERS epointers) { static HANDLE hRunOnce /* = 0 */; if (hRunOnce == 0) { OBJECT_ATTRIBUTES attr; HANDLE hEvent; attr.Length = sizeof(attr); attr.RootDirectory = 0; attr.Attributes = OBJ_INHERIT; attr.ObjectName = NULL; attr.SecurityDescriptor = NULL; attr.SecurityQualityOfService = NULL; /* ask for manual reset, so that once the debugger is started, * every thread will know it */ NtCreateEvent( &hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE ); if (InterlockedCompareExchangePointer( (PVOID)&hRunOnce, hEvent, 0 ) == 0) { /* ok, our event has been set... we're the winning thread */ BOOL ret = start_debugger( epointers, hRunOnce ); DWORD tmp; if (!ret) { /* so that the other threads won't be stuck */ NtSetEvent( hRunOnce, &tmp ); } return ret; } /* someone beat us here... */ CloseHandle( hEvent ); } /* and wait for the winner to have actually created the debugger */ WaitForSingleObject( hRunOnce, INFINITE ); /* in fact, here, we only know that someone has tried to start the debugger, * we'll know by reposting the exception if it has actually attached * to the current process */ return TRUE; } /******************************************************************* * check_resource_write * * Check if the exception is a write attempt to the resource data. * If yes, we unprotect the resources to let broken apps continue * (Windows does this too). */ inline static BOOL check_resource_write( void *addr ) { void *rsrc; DWORD size; MEMORY_BASIC_INFORMATION info; if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE; if (info.State == MEM_FREE || !(info.Type & MEM_IMAGE)) return FALSE; if (!(rsrc = RtlImageDirectoryEntryToData( (HMODULE)info.AllocationBase, TRUE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &size ))) return FALSE; if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE; TRACE( "Broken app is writing to the resource data, enabling work-around\n" ); VirtualProtect( rsrc, size, PAGE_WRITECOPY, NULL ); return TRUE; } /******************************************************************* * check_no_exec * * Check for executing a protected area. */ inline static BOOL check_no_exec( void *addr ) { MEMORY_BASIC_INFORMATION info; if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE; if (info.State == MEM_FREE) return FALSE; /* prot |= PAGE_EXECUTE would be a lot easier, but MS developers * apparently don't grasp the notion of protection bits */ switch(info.Protect) { case PAGE_READONLY: info.Protect = PAGE_EXECUTE_READ; break; case PAGE_READWRITE: info.Protect = PAGE_EXECUTE_READWRITE; break; case PAGE_WRITECOPY: info.Protect = PAGE_EXECUTE_WRITECOPY; break; default: return FALSE; } /* FIXME: we should probably have a per-app option, and maybe a message box */ FIXME( "No-exec fault triggered at %p, enabling work-around\n", addr ); return VirtualProtect( addr, 1, info.Protect, NULL ); } /******************************************************************* * UnhandledExceptionFilter (KERNEL32.@) */ LONG WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers) { const EXCEPTION_RECORD *rec = epointers->ExceptionRecord; if (rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && rec->NumberParameters >= 2) { switch(rec->ExceptionInformation[0]) { case 1: /* write access */ if (check_resource_write( (void *)rec->ExceptionInformation[1] )) return EXCEPTION_CONTINUE_EXECUTION; break; case 8: /* execute access */ if (check_no_exec( (void *)rec->ExceptionInformation[1] )) return EXCEPTION_CONTINUE_EXECUTION; break; } } if (!NtCurrentTeb()->Peb->BeingDebugged) { if (rec->ExceptionCode == CONTROL_C_EXIT) { /* do not launch the debugger on ^C, simply terminate the process */ TerminateProcess( GetCurrentProcess(), 1 ); } if (top_filter) { LONG ret = top_filter( epointers ); if (ret != EXCEPTION_CONTINUE_SEARCH) return ret; } /* FIXME: Should check the current error mode */ if (!start_debugger_atomic( epointers ) || !NtCurrentTeb()->Peb->BeingDebugged) return EXCEPTION_EXECUTE_HANDLER; } return EXCEPTION_CONTINUE_SEARCH; } /*********************************************************************** * SetUnhandledExceptionFilter (KERNEL32.@) */ LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter( LPTOP_LEVEL_EXCEPTION_FILTER filter ) { LPTOP_LEVEL_EXCEPTION_FILTER old = top_filter; top_filter = filter; return old; } /************************************************************************** * FatalAppExitA (KERNEL32.@) */ void WINAPI FatalAppExitA( UINT action, LPCSTR str ) { HMODULE mod = GetModuleHandleA( "user32.dll" ); MessageBoxA_funcptr pMessageBoxA = NULL; WARN("AppExit\n"); if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" ); if (pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK ); else ERR( "%s\n", debugstr_a(str) ); ExitProcess(0); } /************************************************************************** * FatalAppExitW (KERNEL32.@) */ void WINAPI FatalAppExitW( UINT action, LPCWSTR str ) { static const WCHAR User32DllW[] = {'u','s','e','r','3','2','.','d','l','l',0}; HMODULE mod = GetModuleHandleW( User32DllW ); MessageBoxW_funcptr pMessageBoxW = NULL; WARN("AppExit\n"); if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" ); if (pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK ); else ERR( "%s\n", debugstr_w(str) ); ExitProcess(0); } /************************************************************************** * FatalExit (KERNEL32.@) */ void WINAPI FatalExit(int ExitCode) { WARN("FatalExit\n"); ExitProcess(ExitCode); }