VariantChangeTypeEx for VT_ARRAY | type style variants.
[wine] / win32 / 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 <stdio.h>
42 #include "windef.h"
43 #include "winerror.h"
44 #include "winternl.h"
45 #include "wingdi.h"
46 #include "winuser.h"
47 #include "wine/exception.h"
48 #include "wine/library.h"
49 #include "thread.h"
50 #include "stackframe.h"
51 #include "excpt.h"
52 #include "wine/server.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 LPDWORD 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] ? "write" : "read",
120                      rec->ExceptionInformation[1]);
121         else
122             len = snprintf( buffer, size, "Unhandled page fault");
123         break;
124     case EXCEPTION_DATATYPE_MISALIGNMENT:
125         len = snprintf( buffer, size, "Unhandled alignment" );
126         break;
127     case CONTROL_C_EXIT:
128         len = snprintf( buffer, size, "Unhandled ^C");
129         break;
130     case EXCEPTION_CRITICAL_SECTION_WAIT:
131         len = snprintf( buffer, size, "Critical section %08lx wait failed",
132                  rec->ExceptionInformation[0]);
133         break;
134     case EXCEPTION_WINE_STUB:
135         len = snprintf( buffer, size, "Unimplemented function %s.%s called",
136                  (char *)rec->ExceptionInformation[0], (char *)rec->ExceptionInformation[1] );
137         break;
138     case EXCEPTION_WINE_ASSERTION:
139         len = snprintf( buffer, size, "Assertion failed" );
140         break;
141     case EXCEPTION_VM86_INTx:
142         len = snprintf( buffer, size, "Unhandled interrupt %02lx in vm86 mode",
143                  rec->ExceptionInformation[0]);
144         break;
145     case EXCEPTION_VM86_STI:
146         len = snprintf( buffer, size, "Unhandled sti in vm86 mode");
147         break;
148     case EXCEPTION_VM86_PICRETURN:
149         len = snprintf( buffer, size, "Unhandled PIC return in vm86 mode");
150         break;
151     default:
152         len = snprintf( buffer, size, "Unhandled exception 0x%08lx", rec->ExceptionCode);
153         break;
154     }
155     if ((len<0) || (len>=size))
156         return -1;
157 #ifdef __i386__
158     if (ptr->ContextRecord->SegCs != wine_get_cs())
159         len2 = snprintf(buffer+len, size-len,
160                         " at address 0x%04lx:0x%08lx.\nDo you wish to debug it ?",
161                         ptr->ContextRecord->SegCs,
162                         (DWORD)ptr->ExceptionRecord->ExceptionAddress);
163     else
164 #endif
165         len2 = snprintf(buffer+len, size-len,
166                         " at address 0x%08lx.\nDo you wish to debug it ?",
167                         (DWORD)ptr->ExceptionRecord->ExceptionAddress);
168     if ((len2<0) || (len>=size-len))
169         return -1;
170     return len+len2;
171 }
172
173
174 /**********************************************************************
175  *           send_debug_event
176  *
177  * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
178  */
179 static int send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
180 {
181     int ret;
182     HANDLE handle = 0;
183
184     SERVER_START_REQ( queue_exception_event )
185     {
186         req->first   = first_chance;
187         wine_server_add_data( req, context, sizeof(*context) );
188         wine_server_add_data( req, rec, sizeof(*rec) );
189         if (!wine_server_call(req)) handle = reply->handle;
190     }
191     SERVER_END_REQ;
192     if (!handle) return 0;  /* no debugger present or other error */
193
194     /* No need to wait on the handle since the process gets suspended
195      * once the event is passed to the debugger, so when we get back
196      * here the event has been continued already.
197      */
198     SERVER_START_REQ( get_exception_status )
199     {
200         req->handle = handle;
201         wine_server_set_reply( req, context, sizeof(*context) );
202         wine_server_call( req );
203         ret = reply->status;
204     }
205     SERVER_END_REQ;
206     NtClose( handle );
207     return ret;
208 }
209
210 /******************************************************************
211  *              start_debugger
212  *
213  * Does the effective debugger startup according to 'format'
214  */
215 static BOOL     start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
216 {
217     OBJECT_ATTRIBUTES attr;
218     UNICODE_STRING nameW;
219     HKEY                hDbgConf;
220     DWORD               bAuto = FALSE;
221     PROCESS_INFORMATION info;
222     STARTUPINFOA        startup;
223     char*               cmdline;
224     char*               format = NULL;
225     BOOL                ret = FALSE;
226
227     static const WCHAR AeDebugW[] = {'M','a','c','h','i','n','e','\\',
228                                      'S','o','f','t','w','a','r','e','\\',
229                                      'M','i','c','r','o','s','o','f','t','\\',
230                                      'W','i','n','d','o','w','s',' ','N','T','\\',
231                                      'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
232                                      'A','e','D','e','b','u','g',0};
233     static const WCHAR DebuggerW[] = {'D','e','b','u','g','g','e','r',0};
234     static const WCHAR AutoW[] = {'A','u','t','o',0};
235
236     MESSAGE("wine: Unhandled exception, starting debugger...\n");
237
238     attr.Length = sizeof(attr);
239     attr.RootDirectory = 0;
240     attr.ObjectName = &nameW;
241     attr.Attributes = 0;
242     attr.SecurityDescriptor = NULL;
243     attr.SecurityQualityOfService = NULL;
244     RtlInitUnicodeString( &nameW, AeDebugW );
245
246     if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr ))
247     {
248         char buffer[64];
249         KEY_VALUE_PARTIAL_INFORMATION *info;
250         DWORD format_size = 0;
251
252         RtlInitUnicodeString( &nameW, DebuggerW );
253         if (NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
254                              NULL, 0, &format_size ) == STATUS_BUFFER_OVERFLOW)
255         {
256             char *data = HeapAlloc(GetProcessHeap(), 0, format_size);
257             NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
258                              data, format_size, &format_size );
259             info = (KEY_VALUE_PARTIAL_INFORMATION *)data;
260             RtlUnicodeToMultiByteSize( &format_size, (WCHAR *)info->Data, info->DataLength );
261             format = HeapAlloc( GetProcessHeap(), 0, format_size+1 );
262             RtlUnicodeToMultiByteN( format, format_size, NULL,
263                                     (WCHAR *)info->Data, info->DataLength );
264             format[format_size] = 0;
265
266             if (info->Type == REG_EXPAND_SZ)
267             {
268                 char* tmp;
269
270                 /* Expand environment variable references */
271                 format_size=ExpandEnvironmentStringsA(format,NULL,0);
272                 tmp=HeapAlloc(GetProcessHeap(), 0, format_size);
273                 ExpandEnvironmentStringsA(format,tmp,format_size);
274                 HeapFree(GetProcessHeap(), 0, format);
275                 format=tmp;
276             }
277             HeapFree( GetProcessHeap(), 0, data );
278         }
279
280         RtlInitUnicodeString( &nameW, AutoW );
281         if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
282                               buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
283        {
284            info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
285            if (info->Type == REG_DWORD) memcpy( &bAuto, info->Data, sizeof(DWORD) );
286            else if (info->Type == REG_SZ)
287            {
288                WCHAR *str = (WCHAR *)info->Data;
289                str[info->DataLength/sizeof(WCHAR)] = 0;
290                bAuto = atoiW( str );
291            }
292        }
293        else bAuto = TRUE;
294
295        NtClose(hDbgConf);
296     }
297
298     if (format)
299     {
300         cmdline = HeapAlloc(GetProcessHeap(), 0, strlen(format) + 2*20);
301         sprintf(cmdline, format, GetCurrentProcessId(), hEvent);
302         HeapFree(GetProcessHeap(), 0, format);
303     }
304     else
305     {
306         cmdline = HeapAlloc(GetProcessHeap(), 0, 80);
307         sprintf(cmdline, "winedbg --debugmsg -all --auto %ld %p", GetCurrentProcessId(), hEvent);
308     }
309
310     if (!bAuto)
311     {
312         HMODULE                 mod = GetModuleHandleA( "user32.dll" );
313         MessageBoxA_funcptr     pMessageBoxA = NULL;
314
315         if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
316         if (pMessageBoxA)
317         {
318             char buffer[256];
319             format_exception_msg( epointers, buffer, sizeof(buffer) );
320             if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
321             {
322                 TRACE("Killing process\n");
323                 goto EXIT;
324             }
325         }
326     }
327
328     TRACE("Starting debugger %s\n", debugstr_a(cmdline));
329     memset(&startup, 0, sizeof(startup));
330     startup.cb = sizeof(startup);
331     startup.dwFlags = STARTF_USESHOWWINDOW;
332     startup.wShowWindow = SW_SHOWNORMAL;
333     ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &info);
334
335     if (ret) WaitForSingleObject(hEvent, INFINITE);  /* wait for debugger to come up... */
336     else ERR("Couldn't start debugger (%s) (%ld)\n"
337              "Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
338              debugstr_a(cmdline), GetLastError());
339 EXIT:
340     HeapFree(GetProcessHeap(), 0, cmdline);
341     return ret;
342 }
343
344 /******************************************************************
345  *              start_debugger_atomic
346  *
347  * starts the debugger in an atomic way:
348  *      - either the debugger is not started and it is started
349  *      - or the debugger has already been started by another thread
350  *      - or the debugger couldn't be started
351  *
352  * returns TRUE for the two first conditions, FALSE for the last
353  */
354 static  int     start_debugger_atomic(PEXCEPTION_POINTERS epointers)
355 {
356     static HANDLE       hRunOnce /* = 0 */;
357
358     if (hRunOnce == 0)
359     {
360         OBJECT_ATTRIBUTES       attr;
361         HANDLE                  hEvent;
362
363         attr.Length                   = sizeof(attr);
364         attr.RootDirectory            = 0;
365         attr.Attributes               = OBJ_INHERIT;
366         attr.ObjectName               = NULL;
367         attr.SecurityDescriptor       = NULL;
368         attr.SecurityQualityOfService = NULL;
369
370         /* ask for manual reset, so that once the debugger is started,
371          * every thread will know it */
372         NtCreateEvent( &hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE );
373         if (InterlockedCompareExchangePointer( (PVOID)&hRunOnce, hEvent, 0 ) == 0)
374         {
375             /* ok, our event has been set... we're the winning thread */
376             BOOL        ret = start_debugger( epointers, hRunOnce );
377             DWORD       tmp;
378
379             if (!ret)
380             {
381                 /* so that the other threads won't be stuck */
382                 NtSetEvent( hRunOnce, &tmp );
383             }
384             return ret;
385         }
386
387         /* someone beat us here... */
388         CloseHandle( hEvent );
389     }
390
391     /* and wait for the winner to have actually created the debugger */
392     WaitForSingleObject( hRunOnce, INFINITE );
393     /* in fact, here, we only know that someone has tried to start the debugger,
394      * we'll know by reposting the exception if it has actually attached
395      * to the current process */
396     return TRUE;
397 }
398
399
400 /*******************************************************************
401  *         check_resource_write
402  *
403  * Check if the exception is a write attempt to the resource data.
404  * If yes, we unprotect the resources to let broken apps continue
405  * (Windows does this too).
406  */
407 inline static BOOL check_resource_write( const EXCEPTION_RECORD *rec )
408 {
409     void *addr, *rsrc;
410     DWORD size;
411     MEMORY_BASIC_INFORMATION info;
412
413     if (rec->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) return FALSE;
414     if (!rec->ExceptionInformation[0]) return FALSE;  /* not a write access */
415     addr = (void *)rec->ExceptionInformation[1];
416     if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE;
417     if (!(rsrc = RtlImageDirectoryEntryToData( (HMODULE)info.AllocationBase, TRUE,
418                                               IMAGE_DIRECTORY_ENTRY_RESOURCE, &size )))
419         return FALSE;
420     if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE;
421     FIXME( "Broken app is writing to the resource data, enabling work-around\n" );
422     VirtualProtect( rsrc, size, PAGE_WRITECOPY, NULL );
423     return TRUE;
424 }
425
426
427 /*******************************************************************
428  *         UnhandledExceptionFilter   (KERNEL32.@)
429  */
430 DWORD WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers)
431 {
432     int                 status;
433     int                 loop = 0;
434
435     if (check_resource_write( epointers->ExceptionRecord )) return EXCEPTION_CONTINUE_EXECUTION;
436
437     for (loop = 0; loop <= 1; loop++)
438     {
439         /* send a last chance event to the debugger */
440         status = send_debug_event( epointers->ExceptionRecord, FALSE, epointers->ContextRecord );
441         switch (status)
442         {
443         case DBG_CONTINUE:
444             return EXCEPTION_CONTINUE_EXECUTION;
445         case DBG_EXCEPTION_NOT_HANDLED:
446             TerminateProcess( GetCurrentProcess(), epointers->ExceptionRecord->ExceptionCode );
447             break; /* not reached */
448         case 0: /* no debugger is present */
449             if (epointers->ExceptionRecord->ExceptionCode == CONTROL_C_EXIT)
450             {
451                 /* do not launch the debugger on ^C, simply terminate the process */
452                 TerminateProcess( GetCurrentProcess(), 1 );
453             }
454             /* second try, the debugger isn't present... */
455             if (loop == 1) return EXCEPTION_EXECUTE_HANDLER;
456             break;
457         default:
458             FIXME("Unsupported yet debug continue value %d (please report)\n", status);
459             return EXCEPTION_EXECUTE_HANDLER;
460         }
461
462         /* should only be there when loop == 0 */
463
464         if (top_filter)
465         {
466             DWORD ret = top_filter( epointers );
467             if (ret != EXCEPTION_CONTINUE_SEARCH) return ret;
468         }
469
470         /* FIXME: Should check the current error mode */
471
472         if (!start_debugger_atomic( epointers ))
473             return EXCEPTION_EXECUTE_HANDLER;
474         /* now that we should have a debugger attached, try to resend event */
475     }
476
477     return EXCEPTION_EXECUTE_HANDLER;
478 }
479
480
481 /***********************************************************************
482  *            SetUnhandledExceptionFilter   (KERNEL32.@)
483  */
484 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
485                                           LPTOP_LEVEL_EXCEPTION_FILTER filter )
486 {
487     LPTOP_LEVEL_EXCEPTION_FILTER old = top_filter;
488     top_filter = filter;
489     return old;
490 }
491
492
493 /**************************************************************************
494  *           FatalAppExitA   (KERNEL32.@)
495  */
496 void WINAPI FatalAppExitA( UINT action, LPCSTR str )
497 {
498     HMODULE mod = GetModuleHandleA( "user32.dll" );
499     MessageBoxA_funcptr pMessageBoxA = NULL;
500
501     WARN("AppExit\n");
502
503     if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
504     if (pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
505     else ERR( "%s\n", debugstr_a(str) );
506     ExitProcess(0);
507 }
508
509
510 /**************************************************************************
511  *           FatalAppExitW   (KERNEL32.@)
512  */
513 void WINAPI FatalAppExitW( UINT action, LPCWSTR str )
514 {
515     HMODULE mod = GetModuleHandleA( "user32.dll" );
516     MessageBoxW_funcptr pMessageBoxW = NULL;
517
518     WARN("AppExit\n");
519
520     if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" );
521     if (pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
522     else ERR( "%s\n", debugstr_w(str) );
523     ExitProcess(0);
524 }