1996-03-14 18:08:34 +00:00
|
|
|
/*
|
|
|
|
* Win32 exception functions
|
|
|
|
*
|
|
|
|
* Copyright (c) 1996 Onno Hovers, (onno@stack.urc.tue.nl)
|
1999-05-09 16:12:19 +00:00
|
|
|
* Copyright (c) 1999 Alexandre Julliard
|
1996-03-14 18:08:34 +00:00
|
|
|
*
|
2002-03-09 23:29:33 +00:00
|
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
1996-03-14 18:08:34 +00:00
|
|
|
* 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
|
2002-05-31 23:06:46 +00:00
|
|
|
* 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.
|
1996-03-14 18:08:34 +00:00
|
|
|
* Another reason could be that Microsoft does not want others to write
|
2002-05-31 23:06:46 +00:00
|
|
|
* binary compatible implementations of the Win32 API (like us).
|
1996-03-14 18:08:34 +00:00
|
|
|
*
|
2002-05-31 23:06:46 +00:00
|
|
|
* 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
|
1996-03-14 18:08:34 +00:00
|
|
|
* documented!
|
|
|
|
*
|
|
|
|
*/
|
2002-08-28 23:42:34 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include "wine/port.h"
|
1996-03-14 18:08:34 +00:00
|
|
|
|
2003-09-05 23:08:26 +00:00
|
|
|
#include <stdarg.h>
|
2000-02-10 19:03:02 +00:00
|
|
|
#include <stdio.h>
|
2003-09-05 23:08:26 +00:00
|
|
|
#include "ntstatus.h"
|
2000-02-10 19:03:02 +00:00
|
|
|
#include "windef.h"
|
2003-09-05 23:08:26 +00:00
|
|
|
#include "winbase.h"
|
1996-03-14 18:08:34 +00:00
|
|
|
#include "winerror.h"
|
2002-09-12 22:07:02 +00:00
|
|
|
#include "winternl.h"
|
2001-02-20 00:55:17 +00:00
|
|
|
#include "wingdi.h"
|
|
|
|
#include "winuser.h"
|
1999-05-12 13:10:39 +00:00
|
|
|
#include "wine/exception.h"
|
2002-05-16 20:32:16 +00:00
|
|
|
#include "wine/library.h"
|
2002-12-12 23:34:01 +00:00
|
|
|
#include "excpt.h"
|
2001-07-19 00:39:09 +00:00
|
|
|
#include "wine/server.h"
|
2002-09-13 18:52:01 +00:00
|
|
|
#include "wine/unicode.h"
|
2002-03-09 23:29:33 +00:00
|
|
|
#include "wine/debug.h"
|
1996-03-14 18:08:34 +00:00
|
|
|
|
2002-03-09 23:29:33 +00:00
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(seh);
|
1996-03-14 18:08:34 +00:00
|
|
|
|
2000-12-11 03:48:15 +00:00
|
|
|
static PTOP_LEVEL_EXCEPTION_FILTER top_filter;
|
|
|
|
|
2001-02-20 00:55:17 +00:00
|
|
|
typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT);
|
|
|
|
typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT);
|
1997-02-02 19:01:52 +00:00
|
|
|
|
|
|
|
/*******************************************************************
|
2001-02-14 23:11:17 +00:00
|
|
|
* RaiseException (KERNEL32.@)
|
1996-03-14 18:08:34 +00:00
|
|
|
*/
|
2005-02-24 13:15:36 +00:00
|
|
|
void WINAPI RaiseException( DWORD code, DWORD flags, DWORD nbargs, const ULONG_PTR *args )
|
1996-03-14 18:08:34 +00:00
|
|
|
{
|
1999-05-09 16:12:19 +00:00
|
|
|
EXCEPTION_RECORD record;
|
Release 980601
Sun May 31 13:40:13 1998 Alexandre Julliard <julliard@lrc.epfl.ch>
* [if1632/signal.c]
Added display of exception name.
* [loader/task.c]
Yet another attempt at fixing SwitchStackTo/SwitchStackBack.
* [memory/selector.c] [relay32/builtin32.c] [tools/build.c]
[win32/kernel32.c]
Generate an assembly stub for Win32 register functions to make
their names available at link time.
* [programs/*/Makefile.in]
Added hacks to support old resource compiler.
Fri May 29 16:27:14 1998 Marcus Meissner <marcus@jet.franken.de>
* [tools/testrun]
Merge of my testscripts at home into one single perl program
(tested with perl5). Works only on Linux due to 'ps' and 'ipcs'
magic.
* [controls/menu.c]
Added some DefaultMenuItem stubs.
* [debugger/stabs.c]
Fixed stabs loading, now supports (int,int) typeinfo format used
by gcc-2.8 and egcs-1. If it still crashes, please mail me.
* [if1632/][relay32/]
Added msvideo.dll (stubs only)
Replaced some ptr by str for stringcases
Added some new stubs (VxDCall, FindCloseNotif....)
* [misc/network.c]
Some argument fixes.
* [misc/registry.c][misc/cpu.c]
Registry initialization partially rewritten and enhanced.
* [scheduler/*.c]
Some additions so we don't do kill(0,SIGUSR1) (kill processgroup
instead of targeted thread)
Added SetThreadContext.
Thu May 28 23:59:59 1998 Bertho Stultiens <bertho@akhphd.au.dk>
* [tools/wrc/*]
New resource compiler version 1.0.0 (28-May-1998)
* [Make.rules.in] [Makefile.in]
Changed and added rc rules to point to tools/wrc/wrc.
* [configure.in] [include/config.h.in]
Added check for function 'stricmp'.
* [include/resource.h]
Commented out the old resource structure to catch references.
It also includes wrc_rsc.h.
* [include/wrc_rsc.h]
New file. Definitions for the resources generated with wrc.
* [include/windows.h]
Added #ifdef RC_INVOKED to exclude stdarg.h.
Added SS_NOTIFY flag.
* [include/winnls.h]
Added SUBLANG_* definitions and corrected some defaults.
* [loader/libres.c]
Changed the sysres load functions to support wrc generated
resources.
* [resource/sysres_*.rc]
Added #include <windows.h>
* [resource/sysres.c]
Changed declarations to match wrc's output
* [resource/Makefile.in]
Changed rules to work with wrc.
* [tools/makedep.c]
Changed generation of .rc file dependencies to .s target.
Thu May 28 22:28:39 1998 Eric Kohl <ekohl@abo.rhein-zeitung.de>
* [files/file.c][include/windows.c][relay32/kernel32.spec]
Implemented GetFileAttributesEx32A/W.
* [misc/imagelist.h][include/commctrl.h][relay32/comctl32.spec]
Added ImageList_Read and ImageList_Write stubs.
Added ImageList_AddIcon function.
Added ImageList_LoadImage. It is the same as ImageList_LoadImage32A.
* [controls/header.c]
Fixed bitmap drawing bug.
Added full bitmap support.
* [include/commctrl.h]
Added missing header macros.
* [controls/toolbar.c][include/toolbar.h][include/commctrl.h]
[controls/commctrl.c] [relay32/comctl32.spec]
First implementation of toolbar control.
Implemented CreateToolbar, CreateToolbarEx and CreateMappedBitmap.
* [controls/progress.c][controls/status.c]
Some code cleanup.
* [controls/commctrl.c][include/commctrl.h][relay32/comctl32.spec]
Removed CreateStatusWindow16 and DrawStatusText16.
CreateStatusWindow is the same as CreateStatusWindow32A.
DrawStatusText is the same as DrawStatusText32A.
Thu May 28 16:01:28 1998 Matthew J. Francis <asbel@dial.pipex.com>
* [objects/bitmap.c] [objects/bitmap.h] [objects/oembitmap.c]
[objects/dc.c] [graphics/x11drv/bitblt.c]
Added partial implementation of CreateDIBSection, with great thanks
to Ulrich Weigand <weigand@informatik.uni-erlangen.de> for
contributing the bulk of the patch.
Wed May 27 19:04:31 1998 Ulrich Weigand <weigand@informatik.uni-erlangen.de>
* [win32/kernel32.c] [if1632/thunk.c] [include/flatthunk.h]
ThunkConnect16 and related functions moved to emulator.
* [loader/ne/segment.c]
Call DllEntryPoint with correct arguments.
* [relay32/builtin32.c]
Bugfix: Relay debugging did not work for multiple processes.
* [controls/menu.c]
Bugfix: dwItemData was not set for MF_OWNERDRAW menus.
* [if1632/relay.c] [relay32/relay386.c]
Relay messages converted to use DPRINTF.
* [controls/desktop.c] [relay32/user32.spec]
Implemented PaintDesktop.
* [files/profile.c] [if1632/kernel.spec] [misc/network.c]
[misc/printdrv.c] [relay32/winspool.spec]
[win32/ordinals.c] [relay32/kernel32.spec]
Some stubs added.
* [relay32/mpr.spec]
All ordinals were off by one.
Tue May 26 13:32:57 1998 Bill Hawes <whawes@star.net>
* [misc/lstr.c] [include/casemap.h] [tools/unimap.pl]
Added Unicode case conversion routines towupper/towlower,
with mapping tables casemap.h created by tools/unimap.pl.
* [misc/ntdll.c] [include/winnls.h] [relay32/ntdll.spec]
[relay32/advapi.spec]
Minimal implementation of IsTextUnicode, just enough to get
NT4 notepad to open ascii/unicode files.
* [Make.rules.in] [resources/sysres_En.rc]
Added include file dlgs.h for building resource files, so that
resources can refer to defined values (e.g. pshHelp).
* [misc/crtdll.c] [relay32/crtdll.spec]
Use towupper/towlower for 32W case conversions.
* [memory/string.c]
Use towupper for 32W case conversions.
* [ole/ole2nls.c]
Use towupper for 32W case conversions; fix mem leak; minor cleanup
* [controls/edit.c]
Added soft break flag to edit state. Print unknown action values
for WM_VSCROLL (action 190 occurs when running NT4 notepad.)
Mon May 25 22:42:40 1998 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
* [files/file.c]
Care for a pathological case in SetFilePointer.
* [graphics/x11drv/xfont.c]
Handle longer Font names in LFD_ComposeLFD and try to catch errors.
* [loader/pe_image.c]
Unload Dummymodule when PE_LoadLibraryEx32A fails with
PE_LoadImage (makes Encarta 98 installer proceed).
* [misc/registry.c]
Move a check for a special case in RegCreateKeyEx32W after the
check for existence.
Tue May 25 20:18:26 1998 Matthew Becker <mbecker@glasscity.net>
* [misc/ntdll.c]
Added some stubs, just guessing at the size of their param lists.
* [misc/registry.c]
Added stubs for RegUnLoadKey, RegSetKeySecurity, RegSaveKey,
RegRestoreKey, and RegReplaceKey
* [programs/regtest/regtest.c]
Updated registry testing program.
Sun May 24 18:11:40 1998 Alex Priem <alexp@sci.kun.nl>
* [file/profile.c]
Added flag 'return_values' to PROFILE_GetSection.
Sun May 24 13:41:10 1998 James Juran <jrj120@psu.edu>
* [misc/shell.c] [files/directory.c]
Documentation/debugging info additions.
* [*/*.c] [include/*.h]
Moved many extern function definitions to appropriate header files.
Cleaned up a few compile warnings.
If #include "debug.h" is present, removed #include <stdio.h>.
debug.h includes stdio.h, so it is not necessary to include both.
* [graphics/*.c] [if1632/signal.c] [ipc/*.c] [scheduler/*.c]
[win32/*.c] [windows/*.c]
Final patch to convert fprintf statements to new debugging interface.
Some fprintfs are still left, especially in the debugger/ directory.
However, IMHO, it's not worth the effort to change the rest.
Fri May 22 21:58:35 1998 Morten Welinder <terra@diku.dk>
* [windows/keyboard.c]
Correct handling of keys "`-=[]\;',./".
Fri May 22 12:06:00 1998 Per Lindstrm <pelinstr@algonet.se>
* [include/windows.h] [relay32/kernel32.spec] [win32/console.c]
Added stub for ReadConsoleOutputCharacter32A.
Thu May 21 16:45:48 1998 Pascal Cuoq <pcuoq@ens-lyon.fr>
* [ole/ole2nls.c]
Began better implementation of LCMapString32A.
Not very well tested yet, and still need improvements.
* [controls/scroll.c]
Documented functions.
Wed May 20 21:37:56 1998 Peter Hunnisett <hunnise@nortel.ca>
* [include/windows.h][misc/main.c]
Change SystemParameterInfo to support SPI_GETHIGHCONTRAST. Also
include some missing SPI_ definitions.
* [include/dsound.h][multimedia/dsound.c][relay32/dplayx.spec]
Added stubs for DirectPlayLobbyCreate[AW]. Not sure if these
should go into a new files dplayx.c? Anyone care?
* [include/winnls.h]
Added two missing flags for the CompareString32 functions.
1998-06-01 10:44:35 +00:00
|
|
|
|
2002-05-31 23:06:46 +00:00
|
|
|
/* Compose an exception record */
|
|
|
|
|
1999-05-09 16:12:19 +00:00
|
|
|
record.ExceptionCode = code;
|
|
|
|
record.ExceptionFlags = flags & EH_NONCONTINUABLE;
|
|
|
|
record.ExceptionRecord = NULL;
|
|
|
|
record.ExceptionAddress = RaiseException;
|
|
|
|
if (nbargs && args)
|
1996-03-14 18:08:34 +00:00
|
|
|
{
|
1999-05-09 16:12:19 +00:00
|
|
|
if (nbargs > EXCEPTION_MAXIMUM_PARAMETERS) nbargs = EXCEPTION_MAXIMUM_PARAMETERS;
|
|
|
|
record.NumberParameters = nbargs;
|
|
|
|
memcpy( record.ExceptionInformation, args, nbargs * sizeof(*args) );
|
|
|
|
}
|
|
|
|
else record.NumberParameters = 0;
|
1996-03-14 18:08:34 +00:00
|
|
|
|
1999-05-09 16:12:19 +00:00
|
|
|
RtlRaiseException( &record );
|
1996-03-14 18:08:34 +00:00
|
|
|
}
|
|
|
|
|
1997-02-02 19:01:52 +00:00
|
|
|
|
2000-10-26 22:03:34 +00:00
|
|
|
/*******************************************************************
|
|
|
|
* format_exception_msg
|
|
|
|
*/
|
2001-04-23 18:24:38 +00:00
|
|
|
static int format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, int size )
|
2000-10-26 22:03:34 +00:00
|
|
|
{
|
|
|
|
const EXCEPTION_RECORD *rec = ptr->ExceptionRecord;
|
2001-04-23 18:24:38 +00:00
|
|
|
int len,len2;
|
2000-10-26 22:03:34 +00:00
|
|
|
|
|
|
|
switch(rec->ExceptionCode)
|
|
|
|
{
|
|
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled division by zero" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_INT_OVERFLOW:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled overflow" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled array bounds" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ILLEGAL_INSTRUCTION:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled illegal instruction" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_STACK_OVERFLOW:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled stack overflow" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_PRIV_INSTRUCTION:
|
2001-10-21 15:18:15 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled privileged instruction" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
|
|
|
if (rec->NumberParameters == 2)
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled page fault on %s access to 0x%08lx",
|
2000-10-26 22:03:34 +00:00
|
|
|
rec->ExceptionInformation[0] ? "write" : "read",
|
|
|
|
rec->ExceptionInformation[1]);
|
|
|
|
else
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled page fault");
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_DATATYPE_MISALIGNMENT:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled alignment" );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case CONTROL_C_EXIT:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled ^C");
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
2003-04-04 19:41:31 +00:00
|
|
|
case STATUS_POSSIBLE_DEADLOCK:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Critical section %08lx wait failed",
|
2000-10-26 22:03:34 +00:00
|
|
|
rec->ExceptionInformation[0]);
|
|
|
|
break;
|
|
|
|
case EXCEPTION_WINE_STUB:
|
2004-12-14 20:03:23 +00:00
|
|
|
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] );
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
2002-10-28 23:56:58 +00:00
|
|
|
case EXCEPTION_WINE_ASSERTION:
|
|
|
|
len = snprintf( buffer, size, "Assertion failed" );
|
|
|
|
break;
|
2000-10-26 22:03:34 +00:00
|
|
|
case EXCEPTION_VM86_INTx:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled interrupt %02lx in vm86 mode",
|
2000-10-26 22:03:34 +00:00
|
|
|
rec->ExceptionInformation[0]);
|
|
|
|
break;
|
|
|
|
case EXCEPTION_VM86_STI:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled sti in vm86 mode");
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
case EXCEPTION_VM86_PICRETURN:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled PIC return in vm86 mode");
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-04-23 18:24:38 +00:00
|
|
|
len = snprintf( buffer, size, "Unhandled exception 0x%08lx", rec->ExceptionCode);
|
2000-10-26 22:03:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-04-23 18:24:38 +00:00
|
|
|
if ((len<0) || (len>=size))
|
|
|
|
return -1;
|
2000-10-26 22:03:34 +00:00
|
|
|
#ifdef __i386__
|
2002-05-16 20:32:16 +00:00
|
|
|
if (ptr->ContextRecord->SegCs != wine_get_cs())
|
2001-04-23 18:24:38 +00:00
|
|
|
len2 = snprintf(buffer+len, size-len,
|
|
|
|
" at address 0x%04lx:0x%08lx.\nDo you wish to debug it ?",
|
|
|
|
ptr->ContextRecord->SegCs,
|
|
|
|
(DWORD)ptr->ExceptionRecord->ExceptionAddress);
|
2000-10-26 22:03:34 +00:00
|
|
|
else
|
|
|
|
#endif
|
2001-04-23 18:24:38 +00:00
|
|
|
len2 = snprintf(buffer+len, size-len,
|
|
|
|
" at address 0x%08lx.\nDo you wish to debug it ?",
|
|
|
|
(DWORD)ptr->ExceptionRecord->ExceptionAddress);
|
|
|
|
if ((len2<0) || (len>=size-len))
|
|
|
|
return -1;
|
|
|
|
return len+len2;
|
2000-10-26 22:03:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-01-26 20:45:41 +00:00
|
|
|
/**********************************************************************
|
|
|
|
* send_debug_event
|
|
|
|
*
|
|
|
|
* Send an EXCEPTION_DEBUG_EVENT event to the debugger.
|
|
|
|
*/
|
2003-10-14 01:30:42 +00:00
|
|
|
static NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
|
2001-01-26 20:45:41 +00:00
|
|
|
{
|
2003-10-14 01:30:42 +00:00
|
|
|
NTSTATUS ret;
|
2001-01-26 20:45:41 +00:00
|
|
|
HANDLE handle = 0;
|
|
|
|
|
2001-11-30 18:46:42 +00:00
|
|
|
SERVER_START_REQ( queue_exception_event )
|
2001-01-26 20:45:41 +00:00
|
|
|
{
|
|
|
|
req->first = first_chance;
|
2001-11-30 18:46:42 +00:00
|
|
|
wine_server_add_data( req, context, sizeof(*context) );
|
|
|
|
wine_server_add_data( req, rec, sizeof(*rec) );
|
2003-10-14 01:30:42 +00:00
|
|
|
if (!(ret = wine_server_call( req ))) handle = reply->handle;
|
2001-01-26 20:45:41 +00:00
|
|
|
}
|
2001-11-30 18:46:42 +00:00
|
|
|
SERVER_END_REQ;
|
2003-10-14 01:30:42 +00:00
|
|
|
if (ret) return ret;
|
2001-01-26 20:45:41 +00:00
|
|
|
|
|
|
|
/* No need to wait on the handle since the process gets suspended
|
|
|
|
* once the event is passed to the debugger, so when we get back
|
|
|
|
* here the event has been continued already.
|
|
|
|
*/
|
2001-11-30 18:46:42 +00:00
|
|
|
SERVER_START_REQ( get_exception_status )
|
2001-01-26 20:45:41 +00:00
|
|
|
{
|
|
|
|
req->handle = handle;
|
2001-11-30 18:46:42 +00:00
|
|
|
wine_server_set_reply( req, context, sizeof(*context) );
|
|
|
|
wine_server_call( req );
|
|
|
|
ret = reply->status;
|
2001-01-26 20:45:41 +00:00
|
|
|
}
|
2001-11-30 18:46:42 +00:00
|
|
|
SERVER_END_REQ;
|
2001-01-26 20:45:41 +00:00
|
|
|
NtClose( handle );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2001-08-15 17:34:07 +00:00
|
|
|
/******************************************************************
|
|
|
|
* start_debugger
|
|
|
|
*
|
|
|
|
* Does the effective debugger startup according to 'format'
|
1996-03-14 18:08:34 +00:00
|
|
|
*/
|
2001-08-15 17:34:07 +00:00
|
|
|
static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
|
1996-03-14 18:08:34 +00:00
|
|
|
{
|
2002-09-13 18:52:01 +00:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
UNICODE_STRING nameW;
|
2004-03-11 00:47:49 +00:00
|
|
|
char *cmdline, *env, *p;
|
2005-06-17 13:58:33 +00:00
|
|
|
HANDLE hDbgConf;
|
2000-04-30 12:20:31 +00:00
|
|
|
DWORD bAuto = FALSE;
|
2001-08-15 17:34:07 +00:00
|
|
|
PROCESS_INFORMATION info;
|
|
|
|
STARTUPINFOA startup;
|
2001-10-23 00:25:46 +00:00
|
|
|
char* format = NULL;
|
|
|
|
BOOL ret = FALSE;
|
1997-02-02 19:01:52 +00:00
|
|
|
|
2002-09-13 18:52:01 +00:00
|
|
|
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};
|
|
|
|
|
2003-07-09 21:57:56 +00:00
|
|
|
MESSAGE("wine: Unhandled exception (thread %04lx), starting debugger...\n", GetCurrentThreadId());
|
2001-10-21 15:18:15 +00:00
|
|
|
|
2002-09-13 18:52:01 +00:00
|
|
|
attr.Length = sizeof(attr);
|
|
|
|
attr.RootDirectory = 0;
|
|
|
|
attr.ObjectName = &nameW;
|
|
|
|
attr.Attributes = 0;
|
|
|
|
attr.SecurityDescriptor = NULL;
|
|
|
|
attr.SecurityQualityOfService = NULL;
|
|
|
|
RtlInitUnicodeString( &nameW, AeDebugW );
|
2000-11-12 03:43:42 +00:00
|
|
|
|
2002-09-13 18:52:01 +00:00
|
|
|
if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr ))
|
|
|
|
{
|
|
|
|
char buffer[64];
|
|
|
|
KEY_VALUE_PARTIAL_INFORMATION *info;
|
2002-09-29 18:21:06 +00:00
|
|
|
DWORD format_size = 0;
|
2001-10-23 00:25:46 +00:00
|
|
|
|
2002-09-13 18:52:01 +00:00
|
|
|
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 );
|
|
|
|
}
|
2000-04-13 19:28:28 +00:00
|
|
|
|
2002-09-13 18:52:01 +00:00
|
|
|
RtlInitUnicodeString( &nameW, AutoW );
|
|
|
|
if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
|
|
|
|
buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
|
2000-11-12 03:43:42 +00:00
|
|
|
{
|
2002-09-13 18:52:01 +00:00
|
|
|
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 );
|
|
|
|
}
|
2000-11-12 03:43:42 +00:00
|
|
|
}
|
2002-09-13 18:52:01 +00:00
|
|
|
else bAuto = TRUE;
|
|
|
|
|
|
|
|
NtClose(hDbgConf);
|
2002-09-29 18:21:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2004-03-12 02:05:11 +00:00
|
|
|
sprintf(cmdline, "winedbg --auto %ld %ld",
|
2003-04-16 23:09:59 +00:00
|
|
|
GetCurrentProcessId(), (ULONG_PTR)hEvent);
|
2000-04-13 19:28:28 +00:00
|
|
|
}
|
|
|
|
|
2001-02-20 00:55:17 +00:00
|
|
|
if (!bAuto)
|
|
|
|
{
|
2001-08-15 17:34:07 +00:00
|
|
|
HMODULE mod = GetModuleHandleA( "user32.dll" );
|
|
|
|
MessageBoxA_funcptr pMessageBoxA = NULL;
|
|
|
|
|
|
|
|
if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
|
|
|
|
if (pMessageBoxA)
|
|
|
|
{
|
2001-10-23 00:25:46 +00:00
|
|
|
char buffer[256];
|
2001-08-15 17:34:07 +00:00
|
|
|
format_exception_msg( epointers, buffer, sizeof(buffer) );
|
|
|
|
if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
|
|
|
|
{
|
|
|
|
TRACE("Killing process\n");
|
2001-10-23 00:25:46 +00:00
|
|
|
goto EXIT;
|
2001-08-15 17:34:07 +00:00
|
|
|
}
|
|
|
|
}
|
2000-04-13 19:28:28 +00:00
|
|
|
}
|
2001-02-20 00:55:17 +00:00
|
|
|
|
2004-03-11 00:47:49 +00:00
|
|
|
/* remove WINEDEBUG from the environment */
|
|
|
|
env = GetEnvironmentStringsA();
|
|
|
|
for (p = env; *p; p += strlen(p) + 1)
|
|
|
|
{
|
|
|
|
if (!memcmp( p, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 ))
|
|
|
|
{
|
|
|
|
char *next = p + strlen(p) + 1;
|
|
|
|
char *end = next;
|
|
|
|
while (*end) end += strlen(end) + 1;
|
|
|
|
memmove( p, next, end + 1 - next );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-29 18:21:06 +00:00
|
|
|
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;
|
2004-03-11 00:47:49 +00:00
|
|
|
ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info);
|
|
|
|
FreeEnvironmentStringsA( env );
|
2002-09-29 18:21:06 +00:00
|
|
|
|
|
|
|
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());
|
2001-10-23 00:25:46 +00:00
|
|
|
EXIT:
|
2002-09-29 18:21:06 +00:00
|
|
|
HeapFree(GetProcessHeap(), 0, cmdline);
|
2001-10-23 00:25:46 +00:00
|
|
|
return ret;
|
2001-08-15 17:34:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************
|
|
|
|
* start_debugger_atomic
|
|
|
|
*
|
2001-11-19 02:30:01 +00:00
|
|
|
* starts the debugger in an atomic way:
|
2001-08-15 17:34:07 +00:00
|
|
|
* - either the debugger is not started and it is started
|
2001-11-19 02:30:01 +00:00
|
|
|
* - or the debugger has already been started by another thread
|
|
|
|
* - or the debugger couldn't be started
|
2001-08-15 17:34:07 +00:00
|
|
|
*
|
2001-11-19 02:30:01 +00:00
|
|
|
* returns TRUE for the two first conditions, FALSE for the last
|
2001-08-15 17:34:07 +00:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2001-11-19 02:30:01 +00:00
|
|
|
/* ask for manual reset, so that once the debugger is started,
|
|
|
|
* every thread will know it */
|
2001-08-15 17:34:07 +00:00
|
|
|
NtCreateEvent( &hEvent, EVENT_ALL_ACCESS, &attr, TRUE, FALSE );
|
2002-11-21 03:45:01 +00:00
|
|
|
if (InterlockedCompareExchangePointer( (PVOID)&hRunOnce, hEvent, 0 ) == 0)
|
2001-08-15 17:34:07 +00:00
|
|
|
{
|
|
|
|
/* 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;
|
|
|
|
}
|
2002-05-31 23:06:46 +00:00
|
|
|
|
2001-08-15 17:34:07 +00:00
|
|
|
/* someone beat us here... */
|
|
|
|
CloseHandle( hEvent );
|
|
|
|
}
|
2002-05-31 23:06:46 +00:00
|
|
|
|
2001-08-15 17:34:07 +00:00
|
|
|
/* and wait for the winner to have actually created the debugger */
|
|
|
|
WaitForSingleObject( hRunOnce, INFINITE );
|
2001-11-19 02:30:01 +00:00
|
|
|
/* 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 */
|
2001-08-15 17:34:07 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-08-09 20:01:00 +00:00
|
|
|
/*******************************************************************
|
|
|
|
* 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( const EXCEPTION_RECORD *rec )
|
|
|
|
{
|
|
|
|
void *addr, *rsrc;
|
|
|
|
DWORD size;
|
|
|
|
MEMORY_BASIC_INFORMATION info;
|
|
|
|
|
|
|
|
if (rec->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) return FALSE;
|
2004-01-28 21:40:01 +00:00
|
|
|
if (rec->NumberParameters < 2) return FALSE;
|
2002-08-09 20:01:00 +00:00
|
|
|
if (!rec->ExceptionInformation[0]) return FALSE; /* not a write access */
|
|
|
|
addr = (void *)rec->ExceptionInformation[1];
|
|
|
|
if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE;
|
2005-06-05 18:28:04 +00:00
|
|
|
if (info.State == MEM_FREE) return FALSE;
|
2002-08-09 20:01:00 +00:00
|
|
|
if (!(rsrc = RtlImageDirectoryEntryToData( (HMODULE)info.AllocationBase, TRUE,
|
|
|
|
IMAGE_DIRECTORY_ENTRY_RESOURCE, &size )))
|
|
|
|
return FALSE;
|
|
|
|
if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE;
|
2004-06-01 19:45:15 +00:00
|
|
|
TRACE( "Broken app is writing to the resource data, enabling work-around\n" );
|
2002-08-09 20:01:00 +00:00
|
|
|
VirtualProtect( rsrc, size, PAGE_WRITECOPY, NULL );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-15 17:34:07 +00:00
|
|
|
/*******************************************************************
|
|
|
|
* UnhandledExceptionFilter (KERNEL32.@)
|
|
|
|
*/
|
|
|
|
DWORD WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers)
|
|
|
|
{
|
2003-10-14 01:30:42 +00:00
|
|
|
NTSTATUS status;
|
2001-08-15 17:34:07 +00:00
|
|
|
|
2002-08-09 20:01:00 +00:00
|
|
|
if (check_resource_write( epointers->ExceptionRecord )) return EXCEPTION_CONTINUE_EXECUTION;
|
|
|
|
|
2003-10-14 01:30:42 +00:00
|
|
|
if (!NtCurrentTeb()->Peb->BeingDebugged)
|
2001-08-15 17:34:07 +00:00
|
|
|
{
|
2003-10-14 01:30:42 +00:00
|
|
|
if (epointers->ExceptionRecord->ExceptionCode == CONTROL_C_EXIT)
|
|
|
|
{
|
|
|
|
/* do not launch the debugger on ^C, simply terminate the process */
|
|
|
|
TerminateProcess( GetCurrentProcess(), 1 );
|
|
|
|
}
|
2001-08-15 17:34:07 +00:00
|
|
|
|
2003-10-14 01:30:42 +00:00
|
|
|
if (top_filter)
|
|
|
|
{
|
|
|
|
DWORD ret = top_filter( epointers );
|
|
|
|
if (ret != EXCEPTION_CONTINUE_SEARCH) return ret;
|
|
|
|
}
|
2002-05-31 23:06:46 +00:00
|
|
|
|
2003-10-14 01:30:42 +00:00
|
|
|
/* FIXME: Should check the current error mode */
|
2002-05-31 23:06:46 +00:00
|
|
|
|
2003-10-14 01:30:42 +00:00
|
|
|
if (!start_debugger_atomic( epointers ) || !NtCurrentTeb()->Peb->BeingDebugged)
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
2002-05-31 23:06:46 +00:00
|
|
|
}
|
|
|
|
|
2003-10-14 01:30:42 +00:00
|
|
|
/* send a last chance event to the debugger */
|
|
|
|
status = send_debug_event( epointers->ExceptionRecord, FALSE, epointers->ContextRecord );
|
|
|
|
switch (status)
|
|
|
|
{
|
|
|
|
case DBG_CONTINUE:
|
|
|
|
return EXCEPTION_CONTINUE_EXECUTION;
|
|
|
|
case DBG_EXCEPTION_NOT_HANDLED:
|
|
|
|
TerminateProcess( GetCurrentProcess(), epointers->ExceptionRecord->ExceptionCode );
|
|
|
|
break; /* not reached */
|
|
|
|
default:
|
|
|
|
FIXME("Unhandled error on debug event: %lx\n", status);
|
|
|
|
break;
|
|
|
|
}
|
2001-08-15 17:34:07 +00:00
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
1996-03-14 18:08:34 +00:00
|
|
|
}
|
|
|
|
|
1997-02-02 19:01:52 +00:00
|
|
|
|
2000-04-06 20:21:16 +00:00
|
|
|
/***********************************************************************
|
2001-02-14 23:11:17 +00:00
|
|
|
* SetUnhandledExceptionFilter (KERNEL32.@)
|
1996-03-14 18:08:34 +00:00
|
|
|
*/
|
1997-08-24 16:00:30 +00:00
|
|
|
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
|
1997-02-02 19:01:52 +00:00
|
|
|
LPTOP_LEVEL_EXCEPTION_FILTER filter )
|
|
|
|
{
|
2000-12-11 03:48:15 +00:00
|
|
|
LPTOP_LEVEL_EXCEPTION_FILTER old = top_filter;
|
|
|
|
top_filter = filter;
|
1997-02-02 19:01:52 +00:00
|
|
|
return old;
|
1996-03-14 18:08:34 +00:00
|
|
|
}
|
1999-05-12 13:10:39 +00:00
|
|
|
|
|
|
|
|
2000-03-24 21:42:15 +00:00
|
|
|
/**************************************************************************
|
2001-02-14 23:11:17 +00:00
|
|
|
* FatalAppExitA (KERNEL32.@)
|
2000-03-24 21:42:15 +00:00
|
|
|
*/
|
|
|
|
void WINAPI FatalAppExitA( UINT action, LPCSTR str )
|
|
|
|
{
|
2001-02-20 00:55:17 +00:00
|
|
|
HMODULE mod = GetModuleHandleA( "user32.dll" );
|
|
|
|
MessageBoxA_funcptr pMessageBoxA = NULL;
|
|
|
|
|
2000-03-24 21:42:15 +00:00
|
|
|
WARN("AppExit\n");
|
2001-02-20 00:55:17 +00:00
|
|
|
|
|
|
|
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) );
|
2000-03-24 21:42:15 +00:00
|
|
|
ExitProcess(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**************************************************************************
|
2001-02-14 23:11:17 +00:00
|
|
|
* FatalAppExitW (KERNEL32.@)
|
2000-03-24 21:42:15 +00:00
|
|
|
*/
|
|
|
|
void WINAPI FatalAppExitW( UINT action, LPCWSTR str )
|
|
|
|
{
|
2003-04-27 00:31:34 +00:00
|
|
|
static const WCHAR User32DllW[] = {'u','s','e','r','3','2','.','d','l','l',0};
|
|
|
|
|
|
|
|
HMODULE mod = GetModuleHandleW( User32DllW );
|
2001-02-20 00:55:17 +00:00
|
|
|
MessageBoxW_funcptr pMessageBoxW = NULL;
|
|
|
|
|
2000-03-24 21:42:15 +00:00
|
|
|
WARN("AppExit\n");
|
2001-02-20 00:55:17 +00:00
|
|
|
|
|
|
|
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) );
|
2000-03-24 21:42:15 +00:00
|
|
|
ExitProcess(0);
|
|
|
|
}
|
2003-01-13 20:44:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**************************************************************************
|
|
|
|
* FatalExit (KERNEL32.@)
|
|
|
|
*/
|
|
|
|
void WINAPI FatalExit(int ExitCode)
|
|
|
|
{
|
|
|
|
WARN("FatalExit\n");
|
|
|
|
ExitProcess(ExitCode);
|
|
|
|
}
|