#include <rtl.h>
#include <debug.h>

Include dependency graph for vectoreh.c:

Classes
struct	_RTL_VECTORED_HANDLER_ENTRY

Macros
#define	NDEBUG

Typedefs
typedef struct _RTL_VECTORED_HANDLER_ENTRY	RTL_VECTORED_HANDLER_ENTRY

typedef struct _RTL_VECTORED_HANDLER_ENTRY *	PRTL_VECTORED_HANDLER_ENTRY

Functions
VOID NTAPI	RtlpInitializeVectoredExceptionHandling (VOID)

BOOLEAN NTAPI	RtlpCallVectoredHandlers (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN PLIST_ENTRY VectoredHandlerList)

PVOID NTAPI	RtlpAddVectoredHandler (IN ULONG FirstHandler, IN PVECTORED_EXCEPTION_HANDLER VectoredHandler, IN PLIST_ENTRY VectoredHandlerList)

ULONG NTAPI	RtlpRemoveVectoredHandler (IN PVOID VectoredHandlerHandle, IN PLIST_ENTRY VectoredHandlerList)

BOOLEAN NTAPI	RtlCallVectoredExceptionHandlers (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context)

VOID NTAPI	RtlCallVectoredContinueHandlers (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context)

DECLSPEC_HOTPATCH PVOID NTAPI	RtlAddVectoredExceptionHandler (IN ULONG FirstHandler, IN PVECTORED_EXCEPTION_HANDLER VectoredHandler)

DECLSPEC_HOTPATCH PVOID NTAPI	RtlAddVectoredContinueHandler (IN ULONG FirstHandler, IN PVECTORED_EXCEPTION_HANDLER VectoredHandler)

ULONG NTAPI	RtlRemoveVectoredExceptionHandler (IN PVOID VectoredHandlerHandle)

ULONG NTAPI	RtlRemoveVectoredContinueHandler (IN PVOID VectoredHandlerHandle)

Variables
RTL_CRITICAL_SECTION	RtlpVectoredHandlerLock

LIST_ENTRY	RtlpVectoredExceptionList

LIST_ENTRY	RtlpVectoredContinueList

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file vectoreh.c.

Typedef Documentation

◆ PRTL_VECTORED_HANDLER_ENTRY

typedef struct _RTL_VECTORED_HANDLER_ENTRY * PRTL_VECTORED_HANDLER_ENTRY

◆ RTL_VECTORED_HANDLER_ENTRY

typedef struct _RTL_VECTORED_HANDLER_ENTRY RTL_VECTORED_HANDLER_ENTRY

Function Documentation

◆ RtlAddVectoredContinueHandler()

DECLSPEC_HOTPATCH PVOID NTAPI RtlAddVectoredContinueHandler	(	IN ULONG	FirstHandler,
		IN PVECTORED_EXCEPTION_HANDLER	VectoredHandler
	)

Definition at line 311 of file vectoreh.c.

{
    /* Call the shared routine */
    return RtlpAddVectoredHandler(FirstHandler,
                                  VectoredHandler,
                                  &RtlpVectoredContinueList);
}

◆ RtlAddVectoredExceptionHandler()

DECLSPEC_HOTPATCH PVOID NTAPI RtlAddVectoredExceptionHandler	(	IN ULONG	FirstHandler,
		IN PVECTORED_EXCEPTION_HANDLER	VectoredHandler
	)

Definition at line 299 of file vectoreh.c.

{
    /* Call the shared routine */
    return RtlpAddVectoredHandler(FirstHandler,
                                  VectoredHandler,
                                  &RtlpVectoredExceptionList);
}

◆ RtlCallVectoredContinueHandlers()

VOID NTAPI RtlCallVectoredContinueHandlers	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN PCONTEXT	Context
	)

Definition at line 284 of file vectoreh.c.

{
    /*
     * Call the shared routine (ignoring result,
     * execution always continues at this point)
     */
    (VOID)RtlpCallVectoredHandlers(ExceptionRecord,
                                   Context,
                                   &RtlpVectoredContinueList);
}

◆ RtlCallVectoredExceptionHandlers()

BOOLEAN NTAPI RtlCallVectoredExceptionHandlers	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN PCONTEXT	Context
	)

Definition at line 273 of file vectoreh.c.

{
    /* Call the shared routine */
    return RtlpCallVectoredHandlers(ExceptionRecord,
                                    Context,
                                    &RtlpVectoredExceptionList);
}

◆ RtlpAddVectoredHandler()

PVOID NTAPI RtlpAddVectoredHandler	(	IN ULONG	FirstHandler,
		IN PVECTORED_EXCEPTION_HANDLER	VectoredHandler,
		IN PLIST_ENTRY	VectoredHandlerList
	)

Definition at line 154 of file vectoreh.c.

{
    PRTL_VECTORED_HANDLER_ENTRY VectoredHandlerEntry;
 
    /* Allocate our structure */
    VectoredHandlerEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                           0,
                                           sizeof(RTL_VECTORED_HANDLER_ENTRY));
    if (!VectoredHandlerEntry) return NULL;
 
    /* Set it up, encoding the pointer for security */
    VectoredHandlerEntry->VectoredHandler = RtlEncodePointer(VectoredHandler);
    VectoredHandlerEntry->Refs = 1;
 
    /* Lock the list before modifying it */
    RtlEnterCriticalSection(&RtlpVectoredHandlerLock);
 
    /*
     * While holding the list lock, insert the handler
     * at beginning or end of list according to caller.
     */
    if (FirstHandler)
    {
        InsertHeadList(VectoredHandlerList,
                       &VectoredHandlerEntry->ListEntry);
    }
    else
    {
        InsertTailList(VectoredHandlerList,
                       &VectoredHandlerEntry->ListEntry);
    }
 
    /* Done with the list, unlock it */
    RtlLeaveCriticalSection(&RtlpVectoredHandlerLock);
 
    /* Return pointer to the structure as the handle */
    return VectoredHandlerEntry;
}

Referenced by RtlAddVectoredContinueHandler(), and RtlAddVectoredExceptionHandler().

◆ RtlpCallVectoredHandlers()

BOOLEAN NTAPI RtlpCallVectoredHandlers	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN PCONTEXT	Context,
		IN PLIST_ENTRY	VectoredHandlerList
	)

Definition at line 40 of file vectoreh.c.

{
    PLIST_ENTRY CurrentEntry;
    PRTL_VECTORED_HANDLER_ENTRY VectoredExceptionHandler;
    PVECTORED_EXCEPTION_HANDLER VectoredHandler;
    EXCEPTION_POINTERS ExceptionInfo;
    BOOLEAN HandlerRemoved;
    LONG HandlerReturn;
 
    /*
     * Initialize these in case there are no entries,
     * or if no one handled the exception
     */
    HandlerRemoved = FALSE;
    HandlerReturn = EXCEPTION_CONTINUE_SEARCH;
 
    /* Set up the data to pass to the handler */
    ExceptionInfo.ExceptionRecord = ExceptionRecord;
    ExceptionInfo.ContextRecord = Context;
 
    /* Grab the lock */
    RtlEnterCriticalSection(&RtlpVectoredHandlerLock);
 
    /* Loop entries */
    CurrentEntry = VectoredHandlerList->Flink;
    while (CurrentEntry != VectoredHandlerList)
    {
        /* Get the struct */
        VectoredExceptionHandler = CONTAINING_RECORD(CurrentEntry,
                                                     RTL_VECTORED_HANDLER_ENTRY,
                                                     ListEntry);
 
        /* Reference it so it doesn't go away while we are using it */
        VectoredExceptionHandler->Refs++;
 
        /* Drop the lock before calling the handler */
        RtlLeaveCriticalSection(&RtlpVectoredHandlerLock);
 
        /*
         * Get the function pointer, decoding it so we will crash
         * if malicious code has altered it. That is, if something has
         * set VectoredHandler to a non-encoded pointer
         */
        VectoredHandler = RtlDecodePointer(VectoredExceptionHandler->VectoredHandler);
 
        /* Call the handler */
        HandlerReturn = VectoredHandler(&ExceptionInfo);
 
        /* Handler called -- grab the lock to dereference */
        RtlEnterCriticalSection(&RtlpVectoredHandlerLock);
 
        /* Dereference and see if it got deleted */
        VectoredExceptionHandler->Refs--;
        if (VectoredExceptionHandler->Refs == 0)
        {
            /* It did -- do we have to free it now? */
            if (HandlerReturn == EXCEPTION_CONTINUE_EXECUTION)
            {
                /* We don't, just remove it from the list and break out */
                RemoveEntryList(&VectoredExceptionHandler->ListEntry);
                HandlerRemoved = TRUE;
                break;
            }
 
            /*
             * Get the next entry before freeing,
             * and remove the current one from the list
             */
            CurrentEntry = VectoredExceptionHandler->ListEntry.Flink;
            RemoveEntryList(&VectoredExceptionHandler->ListEntry);
 
            /* Free the entry outside of the lock, then reacquire it */
            RtlLeaveCriticalSection(&RtlpVectoredHandlerLock);
            RtlFreeHeap(RtlGetProcessHeap(),
                        0,
                        VectoredExceptionHandler);
            RtlEnterCriticalSection(&RtlpVectoredHandlerLock);
        }
        else
        {
            /* No delete -- should we continue execution? */
            if (HandlerReturn == EXCEPTION_CONTINUE_EXECUTION)
            {
                /* Break out */
                break;
            }
            else
            {
                /* Continue searching the list */
                CurrentEntry = CurrentEntry->Flink;
            }
        }
    }
 
    /* Let go of the lock now */
    RtlLeaveCriticalSection(&RtlpVectoredHandlerLock);
 
    /* Anything to free? */
    if (HandlerRemoved)
    {
        /* Get rid of it */
        RtlFreeHeap(RtlGetProcessHeap(),
                    0,
                    VectoredExceptionHandler);
    }
 
    /* Return whether to continue execution (ignored for continue handlers) */
    return (HandlerReturn == EXCEPTION_CONTINUE_EXECUTION) ? TRUE : FALSE;
}

Referenced by RtlCallVectoredContinueHandlers(), and RtlCallVectoredExceptionHandlers().

◆ RtlpInitializeVectoredExceptionHandling()

VOID NTAPI RtlpInitializeVectoredExceptionHandling ( VOID )

Definition at line 30 of file vectoreh.c.

{
    /* Initialize our two lists and the common lock */
    RtlInitializeCriticalSection(&RtlpVectoredHandlerLock);
    InitializeListHead(&RtlpVectoredExceptionList);
    InitializeListHead(&RtlpVectoredContinueList);
}

Referenced by LdrpInitializeProcess().

◆ RtlpRemoveVectoredHandler()

ULONG NTAPI RtlpRemoveVectoredHandler	(	IN PVOID	VectoredHandlerHandle,
		IN PLIST_ENTRY	VectoredHandlerList
	)

Definition at line 197 of file vectoreh.c.

{
    PLIST_ENTRY CurrentEntry;
    PRTL_VECTORED_HANDLER_ENTRY VectoredExceptionHandler;
    BOOLEAN HandlerRemoved;
    BOOLEAN HandlerFound;
 
    /* Initialize these in case we don't find anything */
    HandlerRemoved = FALSE;
    HandlerFound = FALSE;
 
    /* Acquire list lock */
    RtlEnterCriticalSection(&RtlpVectoredHandlerLock);
 
    /* Loop the list */
    CurrentEntry = VectoredHandlerList->Flink;
    while (CurrentEntry != VectoredHandlerList)
    {
        /* Get the struct */
        VectoredExceptionHandler = CONTAINING_RECORD(CurrentEntry,
                                                     RTL_VECTORED_HANDLER_ENTRY,
                                                     ListEntry);
 
        /* Does it match? */
        if (VectoredExceptionHandler == VectoredHandlerHandle)
        {
            /*
             * Great, this means it is a valid entry.
             * However, it may be in use by the exception
             * dispatcher, so we have a ref count to respect.
             * If we can't remove it now then it will be done
             * right after it is not in use anymore.
             *
             * Caller is supposed to keep track of if it has deleted the
             * entry and should not call us twice for the same entry.
             * We could maybe throw in some kind of ASSERT to detect this
             * if this was to become a problem.
             */
            VectoredExceptionHandler->Refs--;
            if (VectoredExceptionHandler->Refs == 0)
            {
                /* Not in use, ok to remove and free */
                RemoveEntryList(&VectoredExceptionHandler->ListEntry);
                HandlerRemoved = TRUE;
            }
 
            /* Found what we are looking for, stop searching */
            HandlerFound = TRUE;
            break;
        }
        else
        {
            /* Get the next entry */
            CurrentEntry = CurrentEntry->Flink;
        }
    }
 
    /* Done with the list, let go of the lock */
    RtlLeaveCriticalSection(&RtlpVectoredHandlerLock);
 
    /* Can we free what we found? */
    if (HandlerRemoved)
    {
        /* Do it */
        RtlFreeHeap(RtlGetProcessHeap(),
                    0,
                    VectoredExceptionHandler);
    }
 
    /* Return whether we found it */
    return (ULONG)HandlerFound;
}

Referenced by RtlRemoveVectoredContinueHandler(), and RtlRemoveVectoredExceptionHandler().

◆ RtlRemoveVectoredContinueHandler()

ULONG NTAPI RtlRemoveVectoredContinueHandler ( IN PVOID VectoredHandlerHandle )

Definition at line 333 of file vectoreh.c.

{
    /* Call the shared routine */
    return RtlpRemoveVectoredHandler(VectoredHandlerHandle,
                                     &RtlpVectoredContinueList);
}

◆ RtlRemoveVectoredExceptionHandler()

ULONG NTAPI RtlRemoveVectoredExceptionHandler ( IN PVOID VectoredHandlerHandle )

Definition at line 323 of file vectoreh.c.

{
    /* Call the shared routine */
    return RtlpRemoveVectoredHandler(VectoredHandlerHandle,
                                     &RtlpVectoredExceptionList);
}

Variable Documentation

◆ RtlpVectoredContinueList

LIST_ENTRY RtlpVectoredContinueList

Definition at line 17 of file vectoreh.c.

Referenced by RtlAddVectoredContinueHandler(), RtlCallVectoredContinueHandlers(), RtlpInitializeVectoredExceptionHandling(), and RtlRemoveVectoredContinueHandler().

◆ RtlpVectoredExceptionList

LIST_ENTRY RtlpVectoredExceptionList

Definition at line 17 of file vectoreh.c.

Referenced by RtlAddVectoredExceptionHandler(), RtlCallVectoredExceptionHandlers(), RtlpInitializeVectoredExceptionHandling(), and RtlRemoveVectoredExceptionHandler().

◆ RtlpVectoredHandlerLock

RTL_CRITICAL_SECTION RtlpVectoredHandlerLock

Definition at line 16 of file vectoreh.c.

Referenced by RtlpAddVectoredHandler(), RtlpCallVectoredHandlers(), RtlpInitializeVectoredExceptionHandling(), and RtlpRemoveVectoredHandler().

Classes

Macros

Typedefs

Functions

Variables