dlls/ntdll/exception.c

   1 /*
   2  * NT exception handling routines
   3  *
   4  * Copyright 1999 Turchanov Sergey
   5  * Copyright 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
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <signal.h>
  28 #include <stdarg.h>
  29
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winternl.h"
  34 #include "wine/exception.h"
  35 #include "wine/server.h"
  36 #include "wine/list.h"
  37 #include "wine/debug.h"
  38 #include "excpt.h"
  39 #include "ntdll_misc.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  42
  43 /* Exception record for handling exceptions happening inside exception handlers */
  44 typedef struct
  45 {
  46     EXCEPTION_REGISTRATION_RECORD frame;
  47     EXCEPTION_REGISTRATION_RECORD *prevFrame;
  48 } EXC_NESTED_FRAME;
  49
  50 typedef struct
  51 {
  52     struct list                 entry;
  53     PVECTORED_EXCEPTION_HANDLER func;
  54 } VECTORED_HANDLER;
  55
  56 static struct list vectored_handlers = LIST_INIT(vectored_handlers);
  57
  58 static RTL_CRITICAL_SECTION vectored_handlers_section;
  59 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
  60 {
  61     0, 0, &vectored_handlers_section,
  62     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  63       0, 0, { (DWORD_PTR)(__FILE__ ": vectored_handlers_section") }
  64 };
  65 static RTL_CRITICAL_SECTION vectored_handlers_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  66
  67 #ifdef __i386__
  68 # define GET_IP(context) ((LPVOID)(context)->Eip)
  69 #elif defined(__sparc__)
  70 # define GET_IP(context) ((LPVOID)(context)->pc)
  71 #elif defined(__powerpc__)
  72 # define GET_IP(context) ((LPVOID)(context)->Iar)
  73 #elif defined(__ALPHA__)
  74 # define GET_IP(context) ((LPVOID)(context)->Fir)
  75 #elif defined(__x86_64__)
  76 # define GET_IP(context) ((LPVOID)(context)->Rip)
  77 #else
  78 # error You must define GET_IP for this CPU
  79 #endif
  80
  81 /*******************************************************************
  82  *         EXC_RaiseHandler
  83  *
  84  * Handler for exceptions happening inside a handler.
  85  */
  86 static DWORD EXC_RaiseHandler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
  87                                CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
  88 {
  89     if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
  90         return ExceptionContinueSearch;
  91     /* We shouldn't get here so we store faulty frame in dispatcher */
  92     *dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
  93     return ExceptionNestedException;
  94 }
  95
  96
  97 /*******************************************************************
  98  *         EXC_UnwindHandler
  99  *
 100  * Handler for exceptions happening inside an unwind handler.
 101  */
 102 static DWORD EXC_UnwindHandler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
 103                                 CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
 104 {
 105     if (!(rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
 106         return ExceptionContinueSearch;
 107     /* We shouldn't get here so we store faulty frame in dispatcher */
 108     *dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
 109     return ExceptionCollidedUnwind;
 110 }
 111
 112
 113 /*******************************************************************
 114  *         EXC_CallHandler
 115  *
 116  * Call an exception handler, setting up an exception frame to catch exceptions
 117  * happening during the handler execution.
 118  *
 119  * For i386 this function is implemented in assembler in signal_i386.c.
 120  */
 121 #ifndef __i386__
 122 static DWORD EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 123                               CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher,
 124                               PEXCEPTION_HANDLER handler, PEXCEPTION_HANDLER nested_handler)
 125 {
 126     EXC_NESTED_FRAME newframe;
 127     DWORD ret;
 128
 129     newframe.frame.Handler = nested_handler;
 130     newframe.prevFrame     = frame;
 131     __wine_push_frame( &newframe.frame );
 132     ret = handler( record, frame, context, dispatcher );
 133     __wine_pop_frame( &newframe.frame );
 134     return ret;
 135 }
 136 #else
 137 /* in signal_i386.c */
 138 extern DWORD EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 139                               CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher,
 140                               PEXCEPTION_HANDLER handler, PEXCEPTION_HANDLER nested_handler);
 141 #endif
 142
 143 /**********************************************************************
 144  *           wait_suspend
 145  *
 146  * Wait until the thread is no longer suspended.
 147  */
 148 void wait_suspend( CONTEXT *context )
 149 {
 150     LARGE_INTEGER timeout;
 151     int saved_errno = errno;
 152
 153     /* store the context we got at suspend time */
 154     SERVER_START_REQ( set_thread_context )
 155     {
 156         req->handle  = GetCurrentThread();
 157         req->flags   = CONTEXT_FULL;
 158         req->suspend = 1;
 159         wine_server_add_data( req, context, sizeof(*context) );
 160         wine_server_call( req );
 161     }
 162     SERVER_END_REQ;
 163
 164     /* wait with 0 timeout, will only return once the thread is no longer suspended */
 165     timeout.QuadPart = 0;
 166     NTDLL_wait_for_multiple_objects( 0, NULL, SELECT_INTERRUPTIBLE, &timeout, 0 );
 167
 168     /* retrieve the new context */
 169     SERVER_START_REQ( get_thread_context )
 170     {
 171         req->handle  = GetCurrentThread();
 172         req->flags   = CONTEXT_FULL;
 173         req->suspend = 1;
 174         wine_server_set_reply( req, context, sizeof(*context) );
 175         wine_server_call( req );
 176     }
 177     SERVER_END_REQ;
 178
 179     errno = saved_errno;
 180 }
 181
 182
 183 /**********************************************************************
 184  *           send_debug_event
 185  *
 186  * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
 187  */
 188 static NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
 189 {
 190     int ret;
 191     HANDLE handle = 0;
 192
 193     if (!NtCurrentTeb()->Peb->BeingDebugged) return 0;  /* no debugger present */
 194
 195     SERVER_START_REQ( queue_exception_event )
 196     {
 197         req->first   = first_chance;
 198         wine_server_add_data( req, context, sizeof(*context) );
 199         wine_server_add_data( req, rec, sizeof(*rec) );
 200         if (!wine_server_call( req )) handle = reply->handle;
 201     }
 202     SERVER_END_REQ;
 203     if (!handle) return 0;
 204
 205     NTDLL_wait_for_multiple_objects( 1, &handle, SELECT_INTERRUPTIBLE, NULL, 0 );
 206
 207     SERVER_START_REQ( get_exception_status )
 208     {
 209         req->handle = handle;
 210         wine_server_set_reply( req, context, sizeof(*context) );
 211         ret = wine_server_call( req );
 212     }
 213     SERVER_END_REQ;
 214     return ret;
 215 }
 216
 217
 218 /**********************************************************************
 219  *           call_vectored_handlers
 220  *
 221  * Call the vectored handlers chain.
 222  */
 223 static LONG call_vectored_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 224 {
 225     struct list *ptr;
 226     LONG ret = EXCEPTION_CONTINUE_SEARCH;
 227     EXCEPTION_POINTERS except_ptrs;
 228
 229     except_ptrs.ExceptionRecord = rec;
 230     except_ptrs.ContextRecord = context;
 231
 232     RtlEnterCriticalSection( &vectored_handlers_section );
 233     LIST_FOR_EACH( ptr, &vectored_handlers )
 234     {
 235         VECTORED_HANDLER *handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
 236         ret = handler->func( &except_ptrs );
 237         if (ret == EXCEPTION_CONTINUE_EXECUTION) break;
 238     }
 239     RtlLeaveCriticalSection( &vectored_handlers_section );
 240     return ret;
 241 }
 242
 243
 244 /**********************************************************************
 245  *           call_stack_handlers
 246  *
 247  * Call the stack handlers chain.
 248  */
 249 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 250 {
 251     EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
 252     DWORD res;
 253     CONTEXT backup;
 254     memcpy(&backup, context, sizeof(backup));
 255
 256     frame = NtCurrentTeb()->Tib.ExceptionList;
 257     nested_frame = NULL;
 258     while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
 259     {
 260         /* Check frame address */
 261         if (((void*)frame < NtCurrentTeb()->Tib.StackLimit) ||
 262             ((void*)(frame+1) > NtCurrentTeb()->Tib.StackBase) ||
 263             (ULONG_PTR)frame & 3)
 264         {
 265             rec->ExceptionFlags |= EH_STACK_INVALID;
 266             break;
 267         }
 268
 269         /* Call handler */
 270         TRACE( "calling handler at %p code=%x flags=%x\n",
 271                frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
 272         res = EXC_CallHandler( rec, frame, context, &dispatch, frame->Handler, EXC_RaiseHandler );
 273         TRACE( "handler at %p returned %x\n", frame->Handler, res );
 274
 275
 276 #define check_changed(reg)\
 277 \
 278 if(backup.reg != context->reg)\
 279 {\
 280 TRACE(#reg" 0x%08x -> 0x%08x\n", backup.reg, context->reg);\
 281 }
 282
 283         check_changed(Eip)
 284         check_changed(Esp)
 285         check_changed(Ebp)
 286         check_changed(Eax)
 287         check_changed(Ebx)
 288         check_changed(Ecx)
 289         check_changed(Edx)
 290         check_changed(Esi)
 291         check_changed(Edi)
 292         check_changed(EFlags)
 293         check_changed(Dr0)
 294         check_changed(Dr1)
 295         check_changed(Dr2)
 296         check_changed(Dr3)
 297         check_changed(Dr6)
 298         check_changed(Dr7)
 299 #undef check_changed
 300
 301         if (frame == nested_frame)
 302         {
 303             /* no longer nested */
 304             nested_frame = NULL;
 305             rec->ExceptionFlags &= ~EH_NESTED_CALL;
 306         }
 307
 308         switch(res)
 309         {
 310         case ExceptionContinueExecution:
 311             if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
 312             return STATUS_NONCONTINUABLE_EXCEPTION;
 313         case ExceptionContinueSearch:
 314             break;
 315         case ExceptionNestedException:
 316             if (nested_frame < dispatch) nested_frame = dispatch;
 317             rec->ExceptionFlags |= EH_NESTED_CALL;
 318             break;
 319         default:
 320             return STATUS_INVALID_DISPOSITION;
 321         }
 322         frame = frame->Prev;
 323     }
 324     return STATUS_UNHANDLED_EXCEPTION;
 325 }
 326
 327
 328 /*******************************************************************
 329  *              raise_exception
 330  *
 331  * Implementation of NtRaiseException.
 332  */
 333 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
 334 {
 335     NTSTATUS status;
 336
 337     if (first_chance)
 338     {
 339         DWORD c;
 340
 341         TRACE( ">>> first chance code=%x flags=%x addr=%p\n",
 342                rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
 343         for (c = 0; c < rec->NumberParameters; c++)
 344             TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
 345         if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
 346         {
 347             if (rec->ExceptionInformation[1] >> 16)
 348                 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
 349                          rec->ExceptionAddress,
 350                          (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
 351             else
 352                 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
 353                          rec->ExceptionAddress,
 354                          (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
 355         }
 356 #ifdef __i386__
 357         else
 358         {
 359             TRACE(" eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
 360                   context->Eax, context->Ebx, context->Ecx,
 361                   context->Edx, context->Esi, context->Edi );
 362             TRACE(" ebp=%08x esp=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
 363                   context->Ebp, context->Esp, context->SegCs, context->SegDs,
 364                   context->SegEs, context->SegFs, context->SegGs, context->EFlags );
 365         }
 366 #endif
 367         status = send_debug_event( rec, TRUE, context );
 368         if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
 369             return STATUS_SUCCESS;
 370
 371 #ifdef __i386__
 372         /* fix up instruction pointer in context for EXCEPTION_BREAKPOINT */
 373         if (rec->ExceptionCode == EXCEPTION_BREAKPOINT) context->Eip--;
 374 #endif
 375
 376         if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
 377             return STATUS_SUCCESS;
 378
 379         if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
 380             return status;
 381     }
 382
 383     /* last chance exception */
 384     TRACE( ">>> second chance\n");
 385     status = send_debug_event( rec, FALSE, context );
 386     if (status != DBG_CONTINUE)
 387     {
 388         if (rec->ExceptionFlags & EH_STACK_INVALID)
 389             ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
 390         else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
 391             ERR("Process attempted to continue execution after noncontinuable exception.\n");
 392         else
 393             ERR("Unhandled exception code %x flags %x addr %p\n",
 394                 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
 395         NtTerminateProcess( NtCurrentProcess(), 1 );
 396     }
 397     return STATUS_SUCCESS;
 398 }
 399
 400
 401 /*******************************************************************
 402  *              NtRaiseException (NTDLL.@)
 403  */
 404 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
 405 {
 406     NTSTATUS status = raise_exception( rec, context, first_chance );
 407     if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
 408     return status;
 409 }
 410
 411 /***********************************************************************
 412  *              RtlRaiseException (NTDLL.@)
 413  */
 414 void WINAPI __regs_RtlRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context )
 415 {
 416     NTSTATUS status = raise_exception( rec, context, TRUE );
 417     if (status != STATUS_SUCCESS)
 418     {
 419         EXCEPTION_RECORD newrec;
 420         newrec.ExceptionCode    = status;
 421         newrec.ExceptionFlags   = EH_NONCONTINUABLE;
 422         newrec.ExceptionRecord  = rec;
 423         newrec.NumberParameters = 0;
 424         RtlRaiseException( &newrec );  /* never returns */
 425     }
 426 }
 427
 428 /**********************************************************************/
 429
 430 #ifdef DEFINE_REGS_ENTRYPOINT
 431 DEFINE_REGS_ENTRYPOINT( RtlRaiseException, 4, 4 )
 432 #else
 433 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
 434 {
 435     CONTEXT context;
 436     memset( &context, 0, sizeof(context) );
 437     __regs_RtlRaiseException( rec, &context );
 438 }
 439 #endif
 440
 441
 442 /*******************************************************************
 443  *              RtlUnwind (NTDLL.@)
 444  */
 445 void WINAPI __regs_RtlUnwind( EXCEPTION_REGISTRATION_RECORD* pEndFrame, PVOID unusedEip,
 446                               PEXCEPTION_RECORD pRecord, PVOID returnEax, CONTEXT *context )
 447 {
 448     EXCEPTION_RECORD record, newrec;
 449     EXCEPTION_REGISTRATION_RECORD *frame, *dispatch;
 450     DWORD res;
 451
 452 #ifdef __i386__
 453     context->Eax = (DWORD)returnEax;
 454 #endif
 455
 456     /* build an exception record, if we do not have one */
 457     if (!pRecord)
 458     {
 459         record.ExceptionCode    = STATUS_UNWIND;
 460         record.ExceptionFlags   = 0;
 461         record.ExceptionRecord  = NULL;
 462         record.ExceptionAddress = GET_IP(context);
 463         record.NumberParameters = 0;
 464         pRecord = &record;
 465     }
 466
 467     pRecord->ExceptionFlags |= EH_UNWINDING | (pEndFrame ? 0 : EH_EXIT_UNWIND);
 468
 469     TRACE( "code=%x flags=%x\n", pRecord->ExceptionCode, pRecord->ExceptionFlags );
 470
 471     /* get chain of exception frames */
 472     frame = NtCurrentTeb()->Tib.ExceptionList;
 473     while ((frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL) && (frame != pEndFrame))
 474     {
 475         /* Check frame address */
 476         if (pEndFrame && (frame > pEndFrame))
 477         {
 478             newrec.ExceptionCode    = STATUS_INVALID_UNWIND_TARGET;
 479             newrec.ExceptionFlags   = EH_NONCONTINUABLE;
 480             newrec.ExceptionRecord  = pRecord;
 481             newrec.NumberParameters = 0;
 482             RtlRaiseException( &newrec );  /* never returns */
 483         }
 484         if (((void*)frame < NtCurrentTeb()->Tib.StackLimit) ||
 485             ((void*)(frame+1) > NtCurrentTeb()->Tib.StackBase) ||
 486             (UINT_PTR)frame & 3)
 487         {
 488             newrec.ExceptionCode    = STATUS_BAD_STACK;
 489             newrec.ExceptionFlags   = EH_NONCONTINUABLE;
 490             newrec.ExceptionRecord  = pRecord;
 491             newrec.NumberParameters = 0;
 492             RtlRaiseException( &newrec );  /* never returns */
 493         }
 494
 495         /* Call handler */
 496         TRACE( "calling handler at %p code=%x flags=%x\n",
 497                frame->Handler, pRecord->ExceptionCode, pRecord->ExceptionFlags );
 498         res = EXC_CallHandler( pRecord, frame, context, &dispatch, frame->Handler, EXC_UnwindHandler );
 499         TRACE( "handler at %p returned %x\n", frame->Handler, res );
 500
 501         switch(res)
 502         {
 503         case ExceptionContinueSearch:
 504             break;
 505         case ExceptionCollidedUnwind:
 506             frame = dispatch;
 507             break;
 508         default:
 509             newrec.ExceptionCode    = STATUS_INVALID_DISPOSITION;
 510             newrec.ExceptionFlags   = EH_NONCONTINUABLE;
 511             newrec.ExceptionRecord  = pRecord;
 512             newrec.NumberParameters = 0;
 513             RtlRaiseException( &newrec );  /* never returns */
 514             break;
 515         }
 516         frame = __wine_pop_frame( frame );
 517     }
 518 }
 519
 520 /**********************************************************************/
 521
 522 #ifdef DEFINE_REGS_ENTRYPOINT
 523 DEFINE_REGS_ENTRYPOINT( RtlUnwind, 16, 16 )
 524 #else
 525 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID unusedEip,
 526                        PEXCEPTION_RECORD pRecord, PVOID returnEax )
 527 {
 528     CONTEXT context;
 529     memset( &context, 0, sizeof(context) );
 530     __regs_RtlUnwind( pEndFrame, unusedEip, pRecord, returnEax, &context );
 531 }
 532 #endif
 533
 534
 535 /***********************************************************************
 536  *            RtlRaiseStatus  (NTDLL.@)
 537  *
 538  * Raise an exception with ExceptionCode = status
 539  */
 540 void WINAPI RtlRaiseStatus( NTSTATUS status )
 541 {
 542     EXCEPTION_RECORD ExceptionRec;
 543
 544     ExceptionRec.ExceptionCode    = status;
 545     ExceptionRec.ExceptionFlags   = EH_NONCONTINUABLE;
 546     ExceptionRec.ExceptionRecord  = NULL;
 547     ExceptionRec.NumberParameters = 0;
 548     RtlRaiseException( &ExceptionRec );
 549 }
 550
 551
 552 /*******************************************************************
 553  *         RtlAddVectoredExceptionHandler   (NTDLL.@)
 554  */
 555 PVOID WINAPI RtlAddVectoredExceptionHandler( ULONG first, PVECTORED_EXCEPTION_HANDLER func )
 556 {
 557     VECTORED_HANDLER *handler = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*handler) );
 558     if (handler)
 559     {
 560         handler->func = func;
 561         RtlEnterCriticalSection( &vectored_handlers_section );
 562         if (first) list_add_head( &vectored_handlers, &handler->entry );
 563         else list_add_tail( &vectored_handlers, &handler->entry );
 564         RtlLeaveCriticalSection( &vectored_handlers_section );
 565     }
 566     return handler;
 567 }
 568
 569
 570 /*******************************************************************
 571  *         RtlRemoveVectoredExceptionHandler   (NTDLL.@)
 572  */
 573 ULONG WINAPI RtlRemoveVectoredExceptionHandler( PVOID handler )
 574 {
 575     struct list *ptr;
 576     ULONG ret = FALSE;
 577
 578     RtlEnterCriticalSection( &vectored_handlers_section );
 579     LIST_FOR_EACH( ptr, &vectored_handlers )
 580     {
 581         VECTORED_HANDLER *curr_handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
 582         if (curr_handler == handler)
 583         {
 584             list_remove( ptr );
 585             ret = TRUE;
 586             break;
 587         }
 588     }
 589     RtlLeaveCriticalSection( &vectored_handlers_section );
 590     if (ret) RtlFreeHeap( GetProcessHeap(), 0, handler );
 591     return ret;
 592 }
 593
 594
 595 /*************************************************************
 596  *            __wine_exception_handler (NTDLL.@)
 597  *
 598  * Exception handler for exception blocks declared in Wine code.
 599  */
 600 DWORD __wine_exception_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 601                                 CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 602 {
 603     __WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
 604
 605     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND | EH_NESTED_CALL))
 606         return ExceptionContinueSearch;
 607
 608     if (wine_frame->u.filter == (void *)1)  /* special hack for page faults */
 609     {
 610         if (record->ExceptionCode != STATUS_ACCESS_VIOLATION)
 611             return ExceptionContinueSearch;
 612     }
 613     else if (wine_frame->u.filter)
 614     {
 615         EXCEPTION_POINTERS ptrs;
 616         ptrs.ExceptionRecord = record;
 617         ptrs.ContextRecord = context;
 618         switch(wine_frame->u.filter( &ptrs ))
 619         {
 620         case EXCEPTION_CONTINUE_SEARCH:
 621             return ExceptionContinueSearch;
 622         case EXCEPTION_CONTINUE_EXECUTION:
 623             return ExceptionContinueExecution;
 624         case EXCEPTION_EXECUTE_HANDLER:
 625             break;
 626         default:
 627             MESSAGE( "Invalid return value from exception filter\n" );
 628             assert( FALSE );
 629         }
 630     }
 631     /* hack to make GetExceptionCode() work in handler */
 632     wine_frame->ExceptionCode   = record->ExceptionCode;
 633     wine_frame->ExceptionRecord = wine_frame;
 634
 635     RtlUnwind( frame, 0, record, 0 );
 636     __wine_pop_frame( frame );
 637     siglongjmp( wine_frame->jmp, 1 );
 638 }
 639
 640
 641 /*************************************************************
 642  *            __wine_finally_handler (NTDLL.@)
 643  *
 644  * Exception handler for try/finally blocks declared in Wine code.
 645  */
 646 DWORD __wine_finally_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
 647                               CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
 648 {
 649     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 650     {
 651         __WINE_FRAME *wine_frame = (__WINE_FRAME *)frame;
 652         wine_frame->u.finally_func( FALSE );
 653     }
 654     return ExceptionContinueSearch;
 655 }
 656
 657
 658 /*************************************************************
 659  *            __wine_spec_unimplemented_stub
 660  *
 661  * ntdll-specific implementation to avoid depending on kernel functions.
 662  * Can be removed once ntdll.spec no longer contains stubs.
 663  */
 664 void __wine_spec_unimplemented_stub( const char *module, const char *function )
 665 {
 666     EXCEPTION_RECORD record;
 667
 668     record.ExceptionCode    = EXCEPTION_WINE_STUB;
 669     record.ExceptionFlags   = EH_NONCONTINUABLE;
 670     record.ExceptionRecord  = NULL;
 671     record.ExceptionAddress = __wine_spec_unimplemented_stub;
 672     record.NumberParameters = 2;
 673     record.ExceptionInformation[0] = (ULONG_PTR)module;
 674     record.ExceptionInformation[1] = (ULONG_PTR)function;
 675     RtlRaiseException( &record );
 676 }