1 /*
2 * Win32 exception functions
3 *
4 * Copyright (c) 1996 Onno Hovers, (onno@stack.urc.tue.nl)
5 * Copyright (c) 1999 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * Notes:
22 * What really happens behind the scenes of those new
23 * __try{...}__except(..){....} and
24 * __try{...}__finally{...}
25 * statements is simply not documented by Microsoft. There could be different
26 * reasons for this:
27 * One reason could be that they try to hide the fact that exception
28 * handling in Win32 looks almost the same as in OS/2 2.x.
29 * Another reason could be that Microsoft does not want others to write
30 * binary compatible implementations of the Win32 API (like us).
31 *
32 * Whatever the reason, THIS SUCKS!! Ensuring portability or future
33 * compatibility may be valid reasons to keep some things undocumented.
34 * But exception handling is so basic to Win32 that it should be
35 * documented!
36 *
37 */
38 #include "config.h"
39 #include "wine/port.h"
40
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include "ntstatus.h"
44 #define WIN32_NO_STATUS
45 #include "windef.h"
46 #include "winbase.h"
47 #include "winternl.h"
48 #include "wingdi.h"
49 #include "winuser.h"
50 #include "wine/exception.h"
51 #include "wine/library.h"
52 #include "excpt.h"
53 #include "wine/unicode.h"
54 #include "wine/debug.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(seh);
57
58 static PTOP_LEVEL_EXCEPTION_FILTER top_filter;
59
60 typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT);
61 typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT);
62
63 /*******************************************************************
64 * RaiseException (KERNEL32.@)
65 */
66 void WINAPI RaiseException( DWORD code, DWORD flags, DWORD nbargs, const ULONG_PTR *args )
67 {
68 EXCEPTION_RECORD record;
69
70 /* Compose an exception record */
71
72 record.ExceptionCode = code;
73 record.ExceptionFlags = flags & EH_NONCONTINUABLE;
74 record.ExceptionRecord = NULL;
75 record.ExceptionAddress = RaiseException;
76 if (nbargs && args)
77 {
78 if (nbargs > EXCEPTION_MAXIMUM_PARAMETERS) nbargs = EXCEPTION_MAXIMUM_PARAMETERS;
79 record.NumberParameters = nbargs;
80 memcpy( record.ExceptionInformation, args, nbargs * sizeof(*args) );
81 }
82 else record.NumberParameters = 0;
83
84 RtlRaiseException( &record );
85 }
86
87
88 /*******************************************************************
89 * format_exception_msg
90 */
91 static int format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, int size )
92 {
93 const EXCEPTION_RECORD *rec = ptr->ExceptionRecord;
94 int len,len2;
95
96 switch(rec->ExceptionCode)
97 {
98 case EXCEPTION_INT_DIVIDE_BY_ZERO:
99 len = snprintf( buffer, size, "Unhandled division by zero" );
100 break;
101 case EXCEPTION_INT_OVERFLOW:
102 len = snprintf( buffer, size, "Unhandled overflow" );
103 break;
104 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
105 len = snprintf( buffer, size, "Unhandled array bounds" );
106 break;
107 case EXCEPTION_ILLEGAL_INSTRUCTION:
108 len = snprintf( buffer, size, "Unhandled illegal instruction" );
109 break;
110 case EXCEPTION_STACK_OVERFLOW:
111 len = snprintf( buffer, size, "Unhandled stack overflow" );
112 break;
113 case EXCEPTION_PRIV_INSTRUCTION:
114 len = snprintf( buffer, size, "Unhandled privileged instruction" );
115 break;
116 case EXCEPTION_ACCESS_VIOLATION:
117 if (rec->NumberParameters == 2)
118 len = snprintf( buffer, size, "Unhandled page fault on %s access to 0x%08lx",
119 rec->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT ? "write" :
120 rec->ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT ? "execute" : "read",
121 rec->ExceptionInformation[1]);
122 else
123 len = snprintf( buffer, size, "Unhandled page fault");
124 break;
125 case EXCEPTION_DATATYPE_MISALIGNMENT:
126 len = snprintf( buffer, size, "Unhandled alignment" );
127 break;
128 case CONTROL_C_EXIT:
129 len = snprintf( buffer, size, "Unhandled ^C");
130 break;
131 case STATUS_POSSIBLE_DEADLOCK:
132 len = snprintf( buffer, size, "Critical section %08lx wait failed",
133 rec->ExceptionInformation[0]);
134 break;
135 case EXCEPTION_WINE_STUB:
136 if (HIWORD(rec->ExceptionInformation[1]))
137 len = snprintf( buffer, size, "Unimplemented function %s.%s called",
138 (char *)rec->ExceptionInformation[0], (char *)rec->ExceptionInformation[1] );
139 else
140 len = snprintf( buffer, size, "Unimplemented function %s.%ld called",
141 (char *)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
142 break;
143 case EXCEPTION_WINE_ASSERTION:
144 len = snprintf( buffer, size, "Assertion failed" );
145 break;
146 case EXCEPTION_VM86_INTx:
147 len = snprintf( buffer, size, "Unhandled interrupt %02lx in vm86 mode",
148 rec->ExceptionInformation[0]);
149 break;
150 case EXCEPTION_VM86_STI:
151 len = snprintf( buffer, size, "Unhandled sti in vm86 mode");
152 break;
153 case EXCEPTION_VM86_PICRETURN:
154 len = snprintf( buffer, size, "Unhandled PIC return in vm86 mode");
155 break;
156 default:
157 len = snprintf( buffer, size, "Unhandled exception 0x%08x", rec->ExceptionCode);
158 break;
159 }
160 if ((len<0) || (len>=size))
161 return -1;
162 #ifdef __i386__
163 if (ptr->ContextRecord->SegCs != wine_get_cs())
164 len2 = snprintf(buffer+len, size-len, " at address 0x%04x:0x%08x",
165 ptr->ContextRecord->SegCs,
166 (DWORD)ptr->ExceptionRecord->ExceptionAddress);
167 else
168 #endif
169 len2 = snprintf(buffer+len, size-len, " at address %p",
170 ptr->ExceptionRecord->ExceptionAddress);
171 if ((len2<0) || (len>=size-len))
172 return -1;
173 return len+len2;
174 }
175
176
177 /******************************************************************
178 * start_debugger
179 *
180 * Does the effective debugger startup according to 'format'
181 */
182 static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
183 {
184 OBJECT_ATTRIBUTES attr;
185 UNICODE_STRING nameW;
186 char *cmdline, *env, *p;
187 HANDLE hDbgConf;
188 DWORD bAuto = TRUE;
189 PROCESS_INFORMATION info;
190 STARTUPINFOA startup;
191 char* format = NULL;
192 BOOL ret = FALSE;
193 char buffer[256];
194
195 static const WCHAR AeDebugW[] = {'M','a','c','h','i','n','e','\\',
196 'S','o','f','t','w','a','r','e','\\',
197 'M','i','c','r','o','s','o','f','t','\\',
198 'W','i','n','d','o','w','s',' ','N','T','\\',
199 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
200 'A','e','D','e','b','u','g',0};
201 static const WCHAR DebuggerW[] = {'D','e','b','u','g','g','e','r',0};
202 static const WCHAR AutoW[] = {'A','u','t','o',0};
203
204 format_exception_msg( epointers, buffer, sizeof(buffer) );
205 MESSAGE("wine: %s (thread %04x), starting debugger...\n", buffer, GetCurrentThreadId());
206
207 attr.Length = sizeof(attr);
208 attr.RootDirectory = 0;
209 attr.ObjectName = &nameW;
210 attr.Attributes = 0;
211 attr.SecurityDescriptor = NULL;
212 attr.SecurityQualityOfService = NULL;
213 RtlInitUnicodeString( &nameW, AeDebugW );
214
215 if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr ))
216 {
217 char buffer[64];
218 KEY_VALUE_PARTIAL_INFORMATION *info;
219 DWORD format_size = 0;
220
221 RtlInitUnicodeString( &nameW, DebuggerW );
222 if (NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
223 NULL, 0, &format_size ) == STATUS_BUFFER_OVERFLOW)
224 {
225 char *data = HeapAlloc(GetProcessHeap(), 0, format_size);
226 NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
227 data, format_size, &format_size );
228 info = (KEY_VALUE_PARTIAL_INFORMATION *)data;
229 RtlUnicodeToMultiByteSize( &format_size, (WCHAR *)info->Data, info->DataLength );
230 format = HeapAlloc( GetProcessHeap(), 0, format_size+1 );
231 RtlUnicodeToMultiByteN( format, format_size, NULL,
232 (WCHAR *)info->Data, info->DataLength );
233 format[format_size] = 0;
234
235 if (info->Type == REG_EXPAND_SZ)
236 {
237 char* tmp;
238
239 /* Expand environment variable references */
240 format_size=ExpandEnvironmentStringsA(format,NULL,0);
241 tmp=HeapAlloc(GetProcessHeap(), 0, format_size);
242 ExpandEnvironmentStringsA(format,tmp,format_size);
243 HeapFree(GetProcessHeap(), 0, format);
244 format=tmp;
245 }
246 HeapFree( GetProcessHeap(), 0, data );
247 }
248
249 RtlInitUnicodeString( &nameW, AutoW );
250 if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
251 buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
252 {
253 info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
254 if (info->Type == REG_DWORD) memcpy( &bAuto, info->Data, sizeof(DWORD) );
255 else if (info->Type == REG_SZ)
256 {
257 WCHAR *str = (WCHAR *)info->Data;
258 str[info->DataLength/sizeof(WCHAR)] = 0;
259 bAuto = atoiW( str );
260 }
261 }
262
263 NtClose(hDbgConf);
264 }
265
266 if (format)
267 {
268 cmdline = HeapAlloc(GetProcessHeap(), 0, strlen(format) + 2*20);
269 sprintf(cmdline, format, GetCurrentProcessId(), hEvent);
270 HeapFree(GetProcessHeap(), 0, format);
271 }
272 else
273 {
274 cmdline = HeapAlloc(GetProcessHeap(), 0, 80);
275 sprintf(cmdline, "winedbg --auto %d %ld",
276 GetCurrentProcessId(), (ULONG_PTR)hEvent);
277 }
278
279 if (!bAuto)
280 {
281 HMODULE mod = GetModuleHandleA( "user32.dll" );
282 MessageBoxA_funcptr pMessageBoxA = NULL;
283
284 if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
285 if (pMessageBoxA)
286 {
287 static const char msg[] = ".\nDo you wish to debug it?";
288 char buffer[256];
289
290 format_exception_msg( epointers, buffer, sizeof(buffer)-sizeof(msg) );
291 strcat( buffer, msg );
292 if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
293 {
294 TRACE("Killing process\n");
295 goto EXIT;
296 }
297 }
298 }
299
300 /* make WINEDEBUG empty in the environment */
301 env = GetEnvironmentStringsA();
302 for (p = env; *p; p += strlen(p) + 1)
303 {
304 if (!memcmp( p, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 ))
305 {
306 char *next = p + strlen(p);
307 char *end = next + 1;
308 while (*end) end += strlen(end) + 1;
309 memmove( p + sizeof("WINEDEBUG=") - 1, next, end + 1 - next );
310 break;
311 }
312 }
313
314 TRACE("Starting debugger %s\n", debugstr_a(cmdline));
315 memset(&startup, 0, sizeof(startup));
316 startup.cb = sizeof(startup);
317 startup.dwFlags = STARTF_USESHOWWINDOW;
318 startup.wShowWindow = SW_SHOWNORMAL;
319 ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info);
320 FreeEnvironmentStringsA( env );
321
322 if (ret)
323 {
324 /* wait for debugger to come up... */
325 HANDLE handles[2];
326 CloseHandle(info.hThread);
327 handles[0]=hEvent;
328 handles[1]=info.hProcess;
329 WaitForMultipleObjects(2, handles, FALSE, INFINITE);
330 CloseHandle(info.hProcess);
331 }
332 else ERR("Couldn't start debugger (%s) (%d)\n"
333 "Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
334 debugstr_a(cmdline), GetLastError());
335 EXIT:
336 HeapFree(GetProcessHeap(), 0, cmdline);
337 return ret;
338 }
339
340 /******************************************************************
341 * start_debugger_atomic
342 *
343 * starts the debugger in an atomic way:
344 * - either the debugger is not started and it is started
345 * - or the debugger has already been started by another thread
346 * - or the debugger couldn't be started
347 *
348 * returns TRUE for the two first conditions, FALSE for the last
349 */
350 static int start_debugger_atomic(PEXCEPTION_POINTERS epointers)
351 {
352 static HANDLE hRunOnce /* = 0 */;
353
354 if (hRunOnce == 0)
355 {
356 OBJECT_ATTRIBUTES attr;
357 HANDLE hEvent;
358
359 attr.Length = sizeof(attr);
360 attr.RootDirectory = 0;
361 attr.Attributes = OBJ_INHERIT;
362 attr.ObjectName = NULL;
363 attr.SecurityDescriptor = NULL;
364 attr.SecurityQualityOfService = NULL;
365
366 /* ask for manual reset, so that once the debugger is started,
367 * every thread will know it */
368 NtCreateEvent( &hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE );
369 if (InterlockedCompareExchangePointer( (PVOID)&hRunOnce, hEvent, 0 ) == 0)
370 {
371 /* ok, our event has been set... we're the winning thread */
372 BOOL ret = start_debugger( epointers, hRunOnce );
373 DWORD tmp;
374
375 if (!ret)
376 {
377 /* so that the other threads won't be stuck */
378 NtSetEvent( hRunOnce, &tmp );
379 }
380 return ret;
381 }
382
383 /* someone beat us here... */
384 CloseHandle( hEvent );
385 }
386
387 /* and wait for the winner to have actually created the debugger */
388 WaitForSingleObject( hRunOnce, INFINITE );
389 /* in fact, here, we only know that someone has tried to start the debugger,
390 * we'll know by reposting the exception if it has actually attached
391 * to the current process */
392 return TRUE;
393 }
394
395
396 /*******************************************************************
397 * check_resource_write
398 *
399 * Check if the exception is a write attempt to the resource data.
400 * If yes, we unprotect the resources to let broken apps continue
401 * (Windows does this too).
402 */
403 static inline BOOL check_resource_write( void *addr )
404 {
405 void *rsrc;
406 DWORD size;
407 MEMORY_BASIC_INFORMATION info;
408
409 if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE;
410 if (info.State == MEM_FREE || !(info.Type & MEM_IMAGE)) return FALSE;
411 if (!(rsrc = RtlImageDirectoryEntryToData( (HMODULE)info.AllocationBase, TRUE,
412 IMAGE_DIRECTORY_ENTRY_RESOURCE, &size )))
413 return FALSE;
414 if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE;
415 TRACE( "Broken app is writing to the resource data, enabling work-around\n" );
416 VirtualProtect( rsrc, size, PAGE_WRITECOPY, NULL );
417 return TRUE;
418 }
419
420
421 /*******************************************************************
422 * UnhandledExceptionFilter (KERNEL32.@)
423 */
424 LONG WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers)
425 {
426 const EXCEPTION_RECORD *rec = epointers->ExceptionRecord;
427
428 if (rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && rec->NumberParameters >= 2)
429 {
430 switch(rec->ExceptionInformation[0])
431 {
432 case EXCEPTION_WRITE_FAULT:
433 if (check_resource_write( (void *)rec->ExceptionInformation[1] ))
434 return EXCEPTION_CONTINUE_EXECUTION;
435 break;
436 }
437 }
438
439 if (!NtCurrentTeb()->Peb->BeingDebugged)
440 {
441 if (rec->ExceptionCode == CONTROL_C_EXIT)
442 {
443 /* do not launch the debugger on ^C, simply terminate the process */
444 TerminateProcess( GetCurrentProcess(), 1 );
445 }
446
447 if (top_filter)
448 {
449 LONG ret = top_filter( epointers );
450 if (ret != EXCEPTION_CONTINUE_SEARCH) return ret;
451 }
452
453 /* FIXME: Should check the current error mode */
454
455 if (!start_debugger_atomic( epointers ) || !NtCurrentTeb()->Peb->BeingDebugged)
456 return EXCEPTION_EXECUTE_HANDLER;
457 }
458 return EXCEPTION_CONTINUE_SEARCH;
459 }
460
461
462 /***********************************************************************
463 * SetUnhandledExceptionFilter (KERNEL32.@)
464 */
465 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
466 LPTOP_LEVEL_EXCEPTION_FILTER filter )
467 {
468 LPTOP_LEVEL_EXCEPTION_FILTER old = top_filter;
469 top_filter = filter;
470 return old;
471 }
472
473
474 /**************************************************************************
475 * FatalAppExitA (KERNEL32.@)
476 */
477 void WINAPI FatalAppExitA( UINT action, LPCSTR str )
478 {
479 HMODULE mod = GetModuleHandleA( "user32.dll" );
480 MessageBoxA_funcptr pMessageBoxA = NULL;
481
482 WARN("AppExit\n");
483
484 if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
485 if (pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
486 else ERR( "%s\n", debugstr_a(str) );
487 ExitProcess(0);
488 }
489
490
491 /**************************************************************************
492 * FatalAppExitW (KERNEL32.@)
493 */
494 void WINAPI FatalAppExitW( UINT action, LPCWSTR str )
495 {
496 static const WCHAR User32DllW[] = {'u','s','e','r','3','2','.','d','l','l',0};
497
498 HMODULE mod = GetModuleHandleW( User32DllW );
499 MessageBoxW_funcptr pMessageBoxW = NULL;
500
501 WARN("AppExit\n");
502
503 if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" );
504 if (pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
505 else ERR( "%s\n", debugstr_w(str) );
506 ExitProcess(0);
507 }
508
509
510 /**************************************************************************
511 * FatalExit (KERNEL32.@)
512 */
513 void WINAPI FatalExit(int ExitCode)
514 {
515 WARN("FatalExit\n");
516 ExitProcess(ExitCode);
517 }
518
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.