Convert some registry helper functions to use unicode versions of
[wine] / dlls / kernel / except.c
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include "windef.h"
45 #include "winbase.h"
46 #include "winerror.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/server.h"
54 #include "wine/unicode.h"
55 #include "wine/debug.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(seh);
58
59 static PTOP_LEVEL_EXCEPTION_FILTER top_filter;
60
61 typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT);
62 typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT);
63
64 /*******************************************************************
65  *         RaiseException  (KERNEL32.@)
66  */
67 void WINAPI RaiseException( DWORD code, DWORD flags, DWORD nbargs, const ULONG_PTR *args )
68 {
69     EXCEPTION_RECORD record;
70
71     /* Compose an exception record */
72
73     record.ExceptionCode    = code;
74     record.ExceptionFlags   = flags & EH_NONCONTINUABLE;
75     record.ExceptionRecord  = NULL;
76     record.ExceptionAddress = RaiseException;
77     if (nbargs && args)
78     {
79         if (nbargs > EXCEPTION_MAXIMUM_PARAMETERS) nbargs = EXCEPTION_MAXIMUM_PARAMETERS;
80         record.NumberParameters = nbargs;
81         memcpy( record.ExceptionInformation, args, nbargs * sizeof(*args) );
82     }
83     else record.NumberParameters = 0;
84
85     RtlRaiseException( &record );
86 }
87
88
89 /*******************************************************************
90  *         format_exception_msg
91  */
92 static int format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, int size )
93 {
94     const EXCEPTION_RECORD *rec = ptr->ExceptionRecord;
95     int len,len2;
96
97     switch(rec->ExceptionCode)
98     {
99     case EXCEPTION_INT_DIVIDE_BY_ZERO:
100         len = snprintf( buffer, size, "Unhandled division by zero" );
101         break;
102     case EXCEPTION_INT_OVERFLOW:
103         len = snprintf( buffer, size, "Unhandled overflow" );
104         break;
105     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
106         len = snprintf( buffer, size, "Unhandled array bounds" );
107         break;
108     case EXCEPTION_ILLEGAL_INSTRUCTION:
109         len = snprintf( buffer, size, "Unhandled illegal instruction" );
110         break;
111     case EXCEPTION_STACK_OVERFLOW:
112         len = snprintf( buffer, size, "Unhandled stack overflow" );
113         break;
114     case EXCEPTION_PRIV_INSTRUCTION:
115         len = snprintf( buffer, size, "Unhandled privileged instruction" );
116         break;
117     case EXCEPTION_ACCESS_VIOLATION:
118         if (rec->NumberParameters == 2)
119             len = snprintf( buffer, size, "Unhandled page fault on %s access to 0x%08lx",
120                      rec->ExceptionInformation[0] ? "write" : "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%08lx", 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,
165                         " at address 0x%04lx:0x%08lx.\nDo you wish to debug it ?",
166                         ptr->ContextRecord->SegCs,
167                         (DWORD)ptr->ExceptionRecord->ExceptionAddress);
168     else
169 #endif
170         len2 = snprintf(buffer+len, size-len,
171                         " at address 0x%08lx.\nDo you wish to debug it ?",
172                         (DWORD)ptr->ExceptionRecord->ExceptionAddress);
173     if ((len2<0) || (len>=size-len))
174         return -1;
175     return len+len2;
176 }
177
178
179 /**********************************************************************
180  *           send_debug_event
181  *
182  * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
183  */
184 static NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
185 {
186     NTSTATUS ret;
187     HANDLE handle = 0;
188
189     SERVER_START_REQ( queue_exception_event )
190     {
191         req->first   = first_chance;
192         wine_server_add_data( req, context, sizeof(*context) );
193         wine_server_add_data( req, rec, sizeof(*rec) );
194         if (!(ret = wine_server_call( req ))) handle = reply->handle;
195     }
196     SERVER_END_REQ;
197     if (ret) return ret;
198
199     /* No need to wait on the handle since the process gets suspended
200      * once the event is passed to the debugger, so when we get back
201      * here the event has been continued already.
202      */
203     SERVER_START_REQ( get_exception_status )
204     {
205         req->handle = handle;
206         wine_server_set_reply( req, context, sizeof(*context) );
207         wine_server_call( req );
208         ret = reply->status;
209     }
210     SERVER_END_REQ;
211     NtClose( handle );
212     return ret;
213 }
214
215 /******************************************************************
216  *              start_debugger
217  *
218  * Does the effective debugger startup according to 'format'
219  */
220 static BOOL     start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
221 {
222     OBJECT_ATTRIBUTES attr;
223     UNICODE_STRING nameW;
224     char *cmdline, *env, *p;
225     HANDLE              hDbgConf;
226     DWORD               bAuto = FALSE;
227     PROCESS_INFORMATION info;
228     STARTUPINFOA        startup;
229     char*               format = NULL;
230     BOOL                ret = FALSE;
231
232     static const WCHAR AeDebugW[] = {'M','a','c','h','i','n','e','\\',
233                                      'S','o','f','t','w','a','r','e','\\',
234                                      'M','i','c','r','o','s','o','f','t','\\',
235                                      'W','i','n','d','o','w','s',' ','N','T','\\',
236                                      'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
237                                      'A','e','D','e','b','u','g',0};
238     static const WCHAR DebuggerW[] = {'D','e','b','u','g','g','e','r',0};
239     static const WCHAR AutoW[] = {'A','u','t','o',0};
240
241     MESSAGE("wine: Unhandled exception (thread %04lx), starting debugger...\n", GetCurrentThreadId());
242
243     attr.Length = sizeof(attr);
244     attr.RootDirectory = 0;
245     attr.ObjectName = &nameW;
246     attr.Attributes = 0;
247     attr.SecurityDescriptor = NULL;
248     attr.SecurityQualityOfService = NULL;
249     RtlInitUnicodeString( &nameW, AeDebugW );
250
251     if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr ))
252     {
253         char buffer[64];
254         KEY_VALUE_PARTIAL_INFORMATION *info;
255         DWORD format_size = 0;
256
257         RtlInitUnicodeString( &nameW, DebuggerW );
258         if (NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
259                              NULL, 0, &format_size ) == STATUS_BUFFER_OVERFLOW)
260         {
261             char *data = HeapAlloc(GetProcessHeap(), 0, format_size);
262             NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
263                              data, format_size, &format_size );
264             info = (KEY_VALUE_PARTIAL_INFORMATION *)data;
265             RtlUnicodeToMultiByteSize( &format_size, (WCHAR *)info->Data, info->DataLength );
266             format = HeapAlloc( GetProcessHeap(), 0, format_size+1 );
267             RtlUnicodeToMultiByteN( format, format_size, NULL,
268                                     (WCHAR *)info->Data, info->DataLength );
269             format[format_size] = 0;
270
271             if (info->Type == REG_EXPAND_SZ)
272             {
273                 char* tmp;
274
275                 /* Expand environment variable references */
276                 format_size=ExpandEnvironmentStringsA(format,NULL,0);
277                 tmp=HeapAlloc(GetProcessHeap(), 0, format_size);
278                 ExpandEnvironmentStringsA(format,tmp,format_size);
279                 HeapFree(GetProcessHeap(), 0, format);
280                 format=tmp;
281             }
282             HeapFree( GetProcessHeap(), 0, data );
283         }
284
285         RtlInitUnicodeString( &nameW, AutoW );
286         if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
287                               buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
288        {
289            info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
290            if (info->Type == REG_DWORD) memcpy( &bAuto, info->Data, sizeof(DWORD) );
291            else if (info->Type == REG_SZ)
292            {
293                WCHAR *str = (WCHAR *)info->Data;
294                str[info->DataLength/sizeof(WCHAR)] = 0;
295                bAuto = atoiW( str );
296            }
297        }
298        else bAuto = TRUE;
299
300        NtClose(hDbgConf);
301     }
302
303     if (format)
304     {
305         cmdline = HeapAlloc(GetProcessHeap(), 0, strlen(format) + 2*20);
306         sprintf(cmdline, format, GetCurrentProcessId(), hEvent);
307         HeapFree(GetProcessHeap(), 0, format);
308     }
309     else
310     {
311         cmdline = HeapAlloc(GetProcessHeap(), 0, 80);
312         sprintf(cmdline, "winedbg --auto %ld %ld",
313                 GetCurrentProcessId(), (ULONG_PTR)hEvent);
314     }
315
316     if (!bAuto)
317     {
318         HMODULE                 mod = GetModuleHandleA( "user32.dll" );
319         MessageBoxA_funcptr     pMessageBoxA = NULL;
320
321         if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
322         if (pMessageBoxA)
323         {
324             char buffer[256];
325             format_exception_msg( epointers, buffer, sizeof(buffer) );
326             if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
327             {
328                 TRACE("Killing process\n");
329                 goto EXIT;
330             }
331         }
332     }
333
334     /* remove WINEDEBUG from the environment */
335     env = GetEnvironmentStringsA();
336     for (p = env; *p; p += strlen(p) + 1)
337     {
338         if (!memcmp( p, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 ))
339         {
340             char *next = p + strlen(p) + 1;
341             char *end = next;
342             while (*end) end += strlen(end) + 1;
343             memmove( p, next, end + 1 - next );
344             break;
345         }
346     }
347
348     TRACE("Starting debugger %s\n", debugstr_a(cmdline));
349     memset(&startup, 0, sizeof(startup));
350     startup.cb = sizeof(startup);
351     startup.dwFlags = STARTF_USESHOWWINDOW;
352     startup.wShowWindow = SW_SHOWNORMAL;
353     ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info);
354     FreeEnvironmentStringsA( env );
355
356     if (ret) WaitForSingleObject(hEvent, INFINITE);  /* wait for debugger to come up... */
357     else ERR("Couldn't start debugger (%s) (%ld)\n"
358              "Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
359              debugstr_a(cmdline), GetLastError());
360 EXIT:
361     HeapFree(GetProcessHeap(), 0, cmdline);
362     return ret;
363 }
364
365 /******************************************************************
366  *              start_debugger_atomic
367  *
368  * starts the debugger in an atomic way:
369  *      - either the debugger is not started and it is started
370  *      - or the debugger has already been started by another thread
371  *      - or the debugger couldn't be started
372  *
373  * returns TRUE for the two first conditions, FALSE for the last
374  */
375 static  int     start_debugger_atomic(PEXCEPTION_POINTERS epointers)
376 {
377     static HANDLE       hRunOnce /* = 0 */;
378
379     if (hRunOnce == 0)
380     {
381         OBJECT_ATTRIBUTES       attr;
382         HANDLE                  hEvent;
383
384         attr.Length                   = sizeof(attr);
385         attr.RootDirectory            = 0;
386         attr.Attributes               = OBJ_INHERIT;
387         attr.ObjectName               = NULL;
388         attr.SecurityDescriptor       = NULL;
389         attr.SecurityQualityOfService = NULL;
390
391         /* ask for manual reset, so that once the debugger is started,
392          * every thread will know it */
393         NtCreateEvent( &hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE );
394         if (InterlockedCompareExchangePointer( (PVOID)&hRunOnce, hEvent, 0 ) == 0)
395         {
396             /* ok, our event has been set... we're the winning thread */
397             BOOL        ret = start_debugger( epointers, hRunOnce );
398             DWORD       tmp;
399
400             if (!ret)
401             {
402                 /* so that the other threads won't be stuck */
403                 NtSetEvent( hRunOnce, &tmp );
404             }
405             return ret;
406         }
407
408         /* someone beat us here... */
409         CloseHandle( hEvent );
410     }
411
412     /* and wait for the winner to have actually created the debugger */
413     WaitForSingleObject( hRunOnce, INFINITE );
414     /* in fact, here, we only know that someone has tried to start the debugger,
415      * we'll know by reposting the exception if it has actually attached
416      * to the current process */
417     return TRUE;
418 }
419
420
421 /*******************************************************************
422  *         check_resource_write
423  *
424  * Check if the exception is a write attempt to the resource data.
425  * If yes, we unprotect the resources to let broken apps continue
426  * (Windows does this too).
427  */
428 inline static BOOL check_resource_write( const EXCEPTION_RECORD *rec )
429 {
430     void *addr, *rsrc;
431     DWORD size;
432     MEMORY_BASIC_INFORMATION info;
433
434     if (rec->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) return FALSE;
435     if (rec->NumberParameters < 2) return FALSE;
436     if (!rec->ExceptionInformation[0]) return FALSE;  /* not a write access */
437     addr = (void *)rec->ExceptionInformation[1];
438     if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE;
439     if (info.State == MEM_FREE) return FALSE;
440     if (!(rsrc = RtlImageDirectoryEntryToData( (HMODULE)info.AllocationBase, TRUE,
441                                               IMAGE_DIRECTORY_ENTRY_RESOURCE, &size )))
442         return FALSE;
443     if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE;
444     TRACE( "Broken app is writing to the resource data, enabling work-around\n" );
445     VirtualProtect( rsrc, size, PAGE_WRITECOPY, NULL );
446     return TRUE;
447 }
448
449
450 /*******************************************************************
451  *         UnhandledExceptionFilter   (KERNEL32.@)
452  */
453 DWORD WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers)
454 {
455     NTSTATUS status;
456
457     if (check_resource_write( epointers->ExceptionRecord )) return EXCEPTION_CONTINUE_EXECUTION;
458
459     if (!NtCurrentTeb()->Peb->BeingDebugged)
460     {
461         if (epointers->ExceptionRecord->ExceptionCode == CONTROL_C_EXIT)
462         {
463             /* do not launch the debugger on ^C, simply terminate the process */
464             TerminateProcess( GetCurrentProcess(), 1 );
465         }
466
467         if (top_filter)
468         {
469             DWORD ret = top_filter( epointers );
470             if (ret != EXCEPTION_CONTINUE_SEARCH) return ret;
471         }
472
473         /* FIXME: Should check the current error mode */
474
475         if (!start_debugger_atomic( epointers ) || !NtCurrentTeb()->Peb->BeingDebugged)
476             return EXCEPTION_EXECUTE_HANDLER;
477     }
478
479     /* send a last chance event to the debugger */
480     status = send_debug_event( epointers->ExceptionRecord, FALSE, epointers->ContextRecord );
481     switch (status)
482     {
483     case DBG_CONTINUE:
484         return EXCEPTION_CONTINUE_EXECUTION;
485     case DBG_EXCEPTION_NOT_HANDLED:
486         TerminateProcess( GetCurrentProcess(), epointers->ExceptionRecord->ExceptionCode );
487         break; /* not reached */
488     default:
489         FIXME("Unhandled error on debug event: %lx\n", status);
490         break;
491     }
492     return EXCEPTION_EXECUTE_HANDLER;
493 }
494
495
496 /***********************************************************************
497  *            SetUnhandledExceptionFilter   (KERNEL32.@)
498  */
499 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
500                                           LPTOP_LEVEL_EXCEPTION_FILTER filter )
501 {
502     LPTOP_LEVEL_EXCEPTION_FILTER old = top_filter;
503     top_filter = filter;
504     return old;
505 }
506
507
508 /**************************************************************************
509  *           FatalAppExitA   (KERNEL32.@)
510  */
511 void WINAPI FatalAppExitA( UINT action, LPCSTR str )
512 {
513     HMODULE mod = GetModuleHandleA( "user32.dll" );
514     MessageBoxA_funcptr pMessageBoxA = NULL;
515
516     WARN("AppExit\n");
517
518     if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
519     if (pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
520     else ERR( "%s\n", debugstr_a(str) );
521     ExitProcess(0);
522 }
523
524
525 /**************************************************************************
526  *           FatalAppExitW   (KERNEL32.@)
527  */
528 void WINAPI FatalAppExitW( UINT action, LPCWSTR str )
529 {
530     static const WCHAR User32DllW[] = {'u','s','e','r','3','2','.','d','l','l',0};
531
532     HMODULE mod = GetModuleHandleW( User32DllW );
533     MessageBoxW_funcptr pMessageBoxW = NULL;
534
535     WARN("AppExit\n");
536
537     if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" );
538     if (pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
539     else ERR( "%s\n", debugstr_w(str) );
540     ExitProcess(0);
541 }
542
543
544 /**************************************************************************
545  *           FatalExit   (KERNEL32.@)
546  */
547 void WINAPI FatalExit(int ExitCode)
548 {
549     WARN("FatalExit\n");
550     ExitProcess(ExitCode);
551 }