- Don't call ExSystemExceptionFilter() if we know the caller is user mode.
- Get rid of a couple of dependencies on the NTSTATUS being initialized with STATUS_SUCCESS -- indicate success where properly instead.
svn path=/trunk/; revision=42942
35 files changed:
OUT PRTL_ATOM Atom)
{
PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
OUT PRTL_ATOM Atom)
{
PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
- NTSTATUS Status = STATUS_SUCCESS;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LPWSTR CapturedName;
ULONG CapturedSize;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LPWSTR CapturedName;
ULONG CapturedSize;
if (Atom) ProbeForWriteUshort(Atom);
}
}
if (Atom) ProbeForWriteUshort(Atom);
}
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Make sure probe worked */
- if (NT_SUCCESS(Status))
+ /* Call the runtime function */
+ Status = RtlAddAtomToAtomTable(AtomTable, CapturedName, &SafeAtom);
+ if (NT_SUCCESS(Status) && (Atom))
- /* Call the runtime function */
- Status = RtlAddAtomToAtomTable(AtomTable, CapturedName, &SafeAtom);
- if (NT_SUCCESS(Status) && (Atom))
+ /* Success and caller wants the atom back.. .enter SEH */
+ _SEH2_TRY
- /* Success and caller wants the atom back.. .enter SEH */
- _SEH2_TRY
- {
- /* Return the atom */
- *Atom = SafeAtom;
- }
- _SEH2_EXCEPT(ExSystemExceptionFilter())
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ /* Return the atom */
+ *Atom = SafeAtom;
+ _SEH2_EXCEPT(ExSystemExceptionFilter())
+ {
+ /* Get the exception code */
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
}
/* If we captured anything, free it */
}
/* If we captured anything, free it */
OUT PRTL_ATOM Atom)
{
PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
OUT PRTL_ATOM Atom)
{
PRTL_ATOM_TABLE AtomTable = ExpGetGlobalAtomTable();
- NTSTATUS Status = STATUS_SUCCESS;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LPWSTR CapturedName = NULL;
ULONG CapturedSize;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LPWSTR CapturedName = NULL;
ULONG CapturedSize;
if (Atom) ProbeForWriteUshort(Atom);
}
}
if (Atom) ProbeForWriteUshort(Atom);
}
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Make sure probe worked */
- if (NT_SUCCESS(Status))
+ /* Call the runtime function */
+ Status = RtlLookupAtomInAtomTable(AtomTable, CapturedName, &SafeAtom);
+ if (NT_SUCCESS(Status) && (Atom))
- /* Call the runtime function */
- Status = RtlLookupAtomInAtomTable(AtomTable, CapturedName, &SafeAtom);
- if (NT_SUCCESS(Status) && (Atom))
+ /* Success and caller wants the atom back.. .enter SEH */
+ _SEH2_TRY
- /* Success and caller wants the atom back.. .enter SEH */
- _SEH2_TRY
- {
- /* Return the atom */
- *Atom = SafeAtom;
- }
- _SEH2_EXCEPT(ExSystemExceptionFilter())
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ /* Return the atom */
+ *Atom = SafeAtom;
+ _SEH2_EXCEPT(ExSystemExceptionFilter())
+ {
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
}
/* If we captured anything, free it */
}
/* If we captured anything, free it */
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKEVENT Event;
HANDLE hEvent;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKEVENT Event;
HANDLE hEvent;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n",
EventHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtCreateEvent(0x%p, 0x%x, 0x%p)\n",
EventHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(EventHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(EventHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Create the Object */
}
/* Create the Object */
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
HANDLE hEvent;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hEvent;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n",
EventHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtOpenEvent(0x%p, 0x%x, 0x%p)\n",
EventHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(EventHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(EventHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
&hEvent);
/* Check for success */
&hEvent);
/* Check for success */
+ if (NT_SUCCESS(Status))
{
/* Enter SEH for return */
_SEH2_TRY
{
/* Enter SEH for return */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtPulseEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
PAGED_CODE();
DPRINT("NtPulseEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PEVENT_BASIC_INFORMATION BasicInfo =
(PEVENT_BASIC_INFORMATION)EventInformation;
PAGED_CODE();
PEVENT_BASIC_INFORMATION BasicInfo =
(PEVENT_BASIC_INFORMATION)EventInformation;
PAGED_CODE();
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtResetEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtResetEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
/* Check if we were called from user-mode */
- if((PreviousState) && (PreviousMode != KernelMode))
+ if ((PreviousState) && (PreviousMode != KernelMode))
{
/* Entry SEH Block */
_SEH2_TRY
{
/* Entry SEH Block */
_SEH2_TRY
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKEVENT Event;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtSetEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
PAGED_CODE();
DPRINT("NtSetEvent(EventHandle 0%x PreviousState 0%x)\n",
EventHandle, PreviousState);
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousState);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
PKEVENT_PAIR EventPair;
HANDLE hEventPair;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKEVENT_PAIR EventPair;
HANDLE hEventPair;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtCreateEventPair: 0x%p\n", EventPairHandle);
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(EventPairHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(EventPairHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Create the Object */
}
/* Create the Object */
(PVOID*)&EventPair);
/* Check for Success */
(PVOID*)&EventPair);
/* Check for Success */
+ if (NT_SUCCESS(Status))
{
/* Initalize the Event */
DPRINT("Initializing EventPair\n");
{
/* Initalize the Event */
DPRINT("Initializing EventPair\n");
- /* Check for success and return handle */
- if(NT_SUCCESS(Status))
+ /* Check for success */
+ if (NT_SUCCESS(Status))
+ /* Return the handle */
*EventPairHandle = hEventPair;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
*EventPairHandle = hEventPair;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
HANDLE hEventPair;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hEventPair;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(EventPairHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(EventPairHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
- /* Check for success and return handle */
- if(NT_SUCCESS(Status))
+ /* Check for success */
+ if (NT_SUCCESS(Status))
+ /* Return the handle */
*EventPairHandle = hEventPair;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
*EventPairHandle = hEventPair;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Free captured buffer */
if (SafeParams) ExFreePool(SafeParams);
{
/* Free captured buffer */
if (SafeParams) ExFreePool(SafeParams);
- Status = _SEH2_GetExceptionCode();
+
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* If we failed to capture/probe, bail out */
- if (!NT_SUCCESS(Status)) return Status;
-
/* Call the system function directly, because we probed */
ExpRaiseHardError(ErrorStatus,
NumberOfParameters,
/* Call the system function directly, because we probed */
ExpRaiseHardError(ErrorStatus,
NumberOfParameters,
/* Return the response */
*Response = SafeResponse;
}
/* Return the response */
*Response = SafeResponse;
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
HANDLE hMutant;
PKMUTANT Mutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
HANDLE hMutant;
PKMUTANT Mutant;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n",
MutantHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtCreateMutant(0x%p, 0x%x, 0x%p)\n",
MutantHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(MutantHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(MutantHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Create the Mutant Object*/
}
/* Create the Mutant Object*/
&hMutant);
/* Check for success */
&hMutant);
/* Check for success */
+ if (NT_SUCCESS(Status))
{
/* Enter SEH for return */
_SEH2_TRY
{
/* Enter SEH for return */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
HANDLE hMutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hMutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n",
MutantHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtOpenMutant(0x%p, 0x%x, 0x%p)\n",
MutantHandle, DesiredAccess, ObjectAttributes);
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(MutantHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(MutantHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
{
PKMUTANT Mutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKMUTANT Mutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PMUTANT_BASIC_INFORMATION BasicInfo =
(PMUTANT_BASIC_INFORMATION)MutantInformation;
PAGED_CODE();
PMUTANT_BASIC_INFORMATION BasicInfo =
(PMUTANT_BASIC_INFORMATION)MutantInformation;
PAGED_CODE();
(PVOID*)&Mutant,
NULL);
/* Check for Status */
(PVOID*)&Mutant,
NULL);
/* Check for Status */
+ if (NT_SUCCESS(Status))
{
/* Enter SEH Block for return */
_SEH2_TRY
{
/* Enter SEH Block for return */
_SEH2_TRY
BasicInfo->AbandonedState = Mutant->Abandoned;
/* Return the Result Length if requested */
BasicInfo->AbandonedState = Mutant->Abandoned;
/* Return the Result Length if requested */
- if(ResultLength) *ResultLength = sizeof(MUTANT_BASIC_INFORMATION);
+ if (ResultLength) *ResultLength = sizeof(MUTANT_BASIC_INFORMATION);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
{
PKMUTANT Mutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKMUTANT Mutant;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
DPRINT("NtReleaseMutant(MutantHandle 0x%p PreviousCount 0x%p)\n",
MutantHandle,
PreviousCount);
/* Check if we were called from user-mode */
PAGED_CODE();
DPRINT("NtReleaseMutant(MutantHandle 0x%p PreviousCount 0x%p)\n",
MutantHandle,
PreviousCount);
/* Check if we were called from user-mode */
- if((PreviousCount) && (PreviousMode != KernelMode))
+ if ((PreviousCount) && (PreviousMode != KernelMode))
{
/* Entry SEH Block */
_SEH2_TRY
{
/* Entry SEH Block */
_SEH2_TRY
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousCount);
}
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousCount);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
NULL);
/* Check for Success and release if such */
NULL);
/* Check for Success and release if such */
+ if (NT_SUCCESS(Status))
{
/*
* Release the mutant. doing so might raise an exception which we're
{
/*
* Release the mutant. doing so might raise an exception which we're
FALSE);
/* Return the previous count if requested */
FALSE);
/* Return the previous count if requested */
- if(PreviousCount) *PreviousCount = Prev;
+ if (PreviousCount) *PreviousCount = Prev;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
PEPROCESS pProcess;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
OBJECT_ATTRIBUTES ObjectAttributes;
PEPROCESS pProcess;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
OBJECT_ATTRIBUTES ObjectAttributes;
- NTSTATUS Status = STATUS_SUCCESS;
ULONG Log2 = 0;
PVOID Segment = NULL;
PAGED_CODE();
ULONG Log2 = 0;
PVOID Segment = NULL;
PAGED_CODE();
BufferSize,
sizeof(ULONG));
}
BufferSize,
sizeof(ULONG));
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if we failed */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Check if a process was specified */
}
/* Check if a process was specified */
NTSTATUS Status = STATUS_SUCCESS;
/* Check if we were called from user-mode */
NTSTATUS Status = STATUS_SUCCESS;
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Entry SEH Block */
_SEH2_TRY
{
/* Entry SEH Block */
_SEH2_TRY
ProbeForWriteLargeInteger(PerformanceFrequency);
}
}
ProbeForWriteLargeInteger(PerformanceFrequency);
}
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* If the pointers are invalid, bail out */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Enter a new SEH Block */
}
/* Enter a new SEH Block */
*PerformanceCounter = KeQueryPerformanceCounter(&PerfFrequency);
/* Return Frequency if requested */
*PerformanceCounter = KeQueryPerformanceCounter(&PerfFrequency);
/* Return Frequency if requested */
- if(PerformanceFrequency) *PerformanceFrequency = PerfFrequency;
+ if (PerformanceFrequency) *PerformanceFrequency = PerfFrequency;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
MmProbeAndLockPages(Profile->Mdl, PreviousMode, IoWriteAccess);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
MmProbeAndLockPages(Profile->Mdl, PreviousMode, IoWriteAccess);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- /* Fail if we raised an exception */
- if (!NT_SUCCESS(Status))
{
/* Release our lock, free the buffer, dereference and return */
KeReleaseMutex(&ExpProfileMutex, FALSE);
ObDereferenceObject(Profile);
ExFreePool(ProfileObject);
{
/* Release our lock, free the buffer, dereference and return */
KeReleaseMutex(&ExpProfileMutex, FALSE);
ObDereferenceObject(Profile);
ExFreePool(ProfileObject);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
/* Map the pages */
TempLockedBufferAddress = MmMapLockedPages(Profile->Mdl, KernelMode);
/* Map the pages */
TempLockedBufferAddress = MmMapLockedPages(Profile->Mdl, KernelMode);
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Validate interval */
ProbeForWriteUlong(Interval);
}
/* Validate interval */
ProbeForWriteUlong(Interval);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* If pointer was invalid, bail out */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Query the Interval */
}
/* Query the Interval */
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
/* Return Success */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
/* Return Success */
PKSEMAPHORE Semaphore;
HANDLE hSemaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKSEMAPHORE Semaphore;
HANDLE hSemaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(SemaphoreHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(SemaphoreHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Make sure the counts make sense */
}
/* Make sure the counts make sense */
&hSemaphore);
/* Check for success */
&hSemaphore);
/* Check for success */
+ if (NT_SUCCESS(Status))
{
/* Enter SEH Block for return */
_SEH2_TRY
{
/* Enter SEH Block for return */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
HANDLE hSemaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hSemaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Enter SEH Block */
_SEH2_TRY
{
/* Enter SEH Block */
_SEH2_TRY
/* Check handle pointer */
ProbeForWriteHandle(SemaphoreHandle);
}
/* Check handle pointer */
ProbeForWriteHandle(SemaphoreHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
&hSemaphore);
/* Check for success */
&hSemaphore);
/* Check for success */
+ if (NT_SUCCESS(Status))
{
/* Enter SEH Block for return */
_SEH2_TRY
{
/* Enter SEH Block for return */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
OUT PVOID SemaphoreInformation,
IN ULONG SemaphoreInformationLength,
IN SEMAPHORE_INFORMATION_CLASS SemaphoreInformationClass,
OUT PVOID SemaphoreInformation,
IN ULONG SemaphoreInformationLength,
- OUT PULONG ReturnLength OPTIONAL)
+ OUT PULONG ReturnLength OPTIONAL)
{
PKSEMAPHORE Semaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKSEMAPHORE Semaphore;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check buffers and class validity */
PAGED_CODE();
/* Check buffers and class validity */
SemaphoreInformationLength,
ReturnLength,
PreviousMode);
SemaphoreInformationLength,
ReturnLength,
PreviousMode);
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
/* Invalid buffers */
DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status);
{
/* Invalid buffers */
DPRINT("NtQuerySemaphore() failed, Status: 0x%x\n", Status);
NULL);
/* Check for success */
NULL);
/* Check for success */
+ if (NT_SUCCESS(Status))
{
/* Entry SEH Block */
_SEH2_TRY
{
/* Entry SEH Block */
_SEH2_TRY
BasicInfo->MaximumCount = Semaphore->Limit;
/* Return the length */
BasicInfo->MaximumCount = Semaphore->Limit;
/* Return the length */
- if(ReturnLength) *ReturnLength = sizeof(*BasicInfo);
+ if (ReturnLength) *ReturnLength = sizeof(*BasicInfo);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKSEMAPHORE Semaphore;
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKSEMAPHORE Semaphore;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if((PreviousCount) && (PreviousMode != KernelMode))
+ if ((PreviousCount) && (PreviousMode != KernelMode))
{
/* Entry SEH Block */
_SEH2_TRY
{
/* Entry SEH Block */
_SEH2_TRY
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousCount);
}
/* Make sure the state pointer is valid */
ProbeForWriteLong(PreviousCount);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Bail out if pointer was invalid */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Make sure count makes sense */
}
/* Make sure count makes sense */
FALSE);
/* Return the old count if requested */
FALSE);
/* Return the old count if requested */
- if(PreviousCount) *PreviousCount = PrevCount;
+ if (PreviousCount) *PreviousCount = PrevCount;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
+ /* Dereference the Semaphore */
ObDereferenceObject(Semaphore);
}
ObDereferenceObject(Semaphore);
}
ANSI_STRING AValue;
UNICODE_STRING WValue;
KPROCESSOR_MODE PreviousMode;
ANSI_STRING AValue;
UNICODE_STRING WValue;
KPROCESSOR_MODE PreviousMode;
- NTSTATUS Status = STATUS_SUCCESS;
-
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
if (ReturnLength != NULL) ProbeForWriteUlong(ReturnLength);
}
if (ReturnLength != NULL) ProbeForWriteUlong(ReturnLength);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status)) return Status;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
NewSystemTime = ProbeForReadLargeInteger(SystemTime);
if(PreviousTime) ProbeForWriteLargeInteger(PreviousTime);
}
NewSystemTime = ProbeForReadLargeInteger(SystemTime);
if(PreviousTime) ProbeForWriteLargeInteger(PreviousTime);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* If the pointers were invalid, bail out */
- if(!NT_SUCCESS(Status)) return Status;
}
/* Make sure we have permission to change the time */
}
/* Make sure we have permission to change the time */
- if(!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
+ if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
{
DPRINT1("NtSetSystemTime: Caller requires the "
"SeSystemtimePrivilege privilege!\n");
{
DPRINT1("NtSetSystemTime: Caller requires the "
"SeSystemtimePrivilege privilege!\n");
KeSetSystemTime(&NewSystemTime, &OldSystemTime, FALSE, NULL);
/* Check if caller wanted previous time */
KeSetSystemTime(&NewSystemTime, &OldSystemTime, FALSE, NULL);
/* Check if caller wanted previous time */
{
/* Enter SEH Block for return */
_SEH2_TRY
{
/* Enter SEH Block for return */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
PAGED_CODE();
/* Check if we were called from user-mode */
PAGED_CODE();
/* Check if we were called from user-mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
*/
KeQuerySystemTime(SystemTime);
}
*/
KeQuerySystemTime(SystemTime);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Get the exception code */
+ Status = _SEH2_GetExceptionCode();
KIRQL OldIrql;
PETHREAD TimerThread;
ULONG DerefsToDo = 1;
KIRQL OldIrql;
PETHREAD TimerThread;
ULONG DerefsToDo = 1;
- NTSTATUS Status = STATUS_SUCCESS;
- /* Check Parameter Validity */
+ /* Check if we need to probe */
if ((CurrentState) && (PreviousMode != KernelMode))
{
_SEH2_TRY
{
if ((CurrentState) && (PreviousMode != KernelMode))
{
_SEH2_TRY
{
+ /* Make sure the pointer is valid */
ProbeForWriteBoolean(CurrentState);
}
ProbeForWriteBoolean(CurrentState);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Get the Timer Object */
}
/* Get the Timer Object */
/* Dereference the Object */
ObDereferenceObjectEx(Timer, DerefsToDo);
/* Dereference the Object */
ObDereferenceObjectEx(Timer, DerefsToDo);
- /* Make sure it's safe to write to the handle */
+ /* Check if caller wants the state */
if (CurrentState)
{
_SEH2_TRY
{
if (CurrentState)
{
_SEH2_TRY
{
+ /* Return the Timer State */
*CurrentState = State;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
*CurrentState = State;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
PETIMER Timer;
HANDLE hTimer;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETIMER Timer;
HANDLE hTimer;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check for correct timer type */
PAGED_CODE();
/* Check for correct timer type */
return STATUS_INVALID_PARAMETER_4;
}
return STATUS_INVALID_PARAMETER_4;
}
- /* Check Parameter Validity */
+ /* Check if we need to probe */
if (PreviousMode != KernelMode)
{
_SEH2_TRY
{
if (PreviousMode != KernelMode)
{
_SEH2_TRY
{
+ /* Make sure the pointer is valid */
ProbeForWriteHandle(TimerHandle);
}
ProbeForWriteHandle(TimerHandle);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Create the Object */
}
/* Create the Object */
/* Check for success */
if (NT_SUCCESS(Status))
{
/* Check for success */
if (NT_SUCCESS(Status))
{
- /* Make sure it's safe to write to the handle */
+ /* Return the Timer Handle */
*TimerHandle = hTimer;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
*TimerHandle = hTimer;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
HANDLE hTimer;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hTimer;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check Parameter Validity */
PAGED_CODE();
/* Check Parameter Validity */
+ /* Make sure the pointer is valid */
ProbeForWriteHandle(TimerHandle);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
ProbeForWriteHandle(TimerHandle);
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
&hTimer);
if (NT_SUCCESS(Status))
{
&hTimer);
if (NT_SUCCESS(Status))
{
- /* Make sure it's safe to write to the handle */
+ /* Return the Timer Handle */
*TimerHandle = hTimer;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
*TimerHandle = hTimer;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
TimerInformationLength,
ReturnLength,
PreviousMode);
TimerInformationLength,
ReturnLength,
PreviousMode);
- if(!NT_SUCCESS(Status)) return Status;
+ if (!NT_SUCCESS(Status)) return Status;
/* Get the Timer Object */
Status = ObReferenceObjectByHandle(TimerHandle,
/* Get the Timer Object */
Status = ObReferenceObjectByHandle(TimerHandle,
PreviousMode,
(PVOID*)&Timer,
NULL);
PreviousMode,
(PVOID*)&Timer,
NULL);
+ if (NT_SUCCESS(Status))
{
/* Return the Basic Information */
_SEH2_TRY
{
/* Return the Basic Information */
_SEH2_TRY
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
/* Check for a valid Period */
if (Period < 0) return STATUS_INVALID_PARAMETER_6;
/* Check for a valid Period */
if (Period < 0) return STATUS_INVALID_PARAMETER_6;
- /* Check Parameter Validity */
+ /* Check if we need to probe */
if (PreviousMode != KernelMode)
{
_SEH2_TRY
{
if (PreviousMode != KernelMode)
{
_SEH2_TRY
{
+ /* Probe and capture the due time */
TimerDueTime = ProbeForReadLargeInteger(DueTime);
TimerDueTime = ProbeForReadLargeInteger(DueTime);
+
+ /* Probe the state pointer if one was passed */
if (PreviousState) ProbeForWriteBoolean(PreviousState);
}
if (PreviousState) ProbeForWriteBoolean(PreviousState);
}
- _SEH2_EXCEPT(ExSystemExceptionFilter())
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
/* Dereference if it was previously enabled */
if (DerefsToDo) ObDereferenceObjectEx(Timer, DerefsToDo);
/* Dereference if it was previously enabled */
if (DerefsToDo) ObDereferenceObjectEx(Timer, DerefsToDo);
- /* Make sure it's safe to write to the handle */
+ /* Check if we need to return the State */
+ /* Return the Timer State */
*PreviousState = State;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
*PreviousState = State;
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
{
LUID NewLuid;
KPROCESSOR_MODE PreviousMode;
{
LUID NewLuid;
KPROCESSOR_MODE PreviousMode;
- NTSTATUS Status = STATUS_SUCCESS;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
}
Status = ExpAllocateLocallyUniqueId(&NewLuid);
}
Status = ExpAllocateLocallyUniqueId(&NewLuid);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
IN ULONG FileInformationSize,
OUT PVOID FileInformation)
{
IN ULONG FileInformationSize,
OUT PVOID FileInformation)
{
- NTSTATUS Status = STATUS_SUCCESS;
KPROCESSOR_MODE AccessMode = ExGetPreviousMode();
DUMMY_FILE_OBJECT DummyFileObject;
FILE_NETWORK_OPEN_INFORMATION NetworkOpenInfo;
KPROCESSOR_MODE AccessMode = ExGetPreviousMode();
DUMMY_FILE_OBJECT DummyFileObject;
FILE_NETWORK_OPEN_INFORMATION NetworkOpenInfo;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status))return Status;
}
/* Check if this is a basic or full request */
}
/* Check if this is a basic or full request */
HANDLE LocalHandle = 0;
LARGE_INTEGER SafeAllocationSize;
PVOID SystemEaBuffer = NULL;
HANDLE LocalHandle = 0;
LARGE_INTEGER SafeAllocationSize;
PVOID SystemEaBuffer = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
OPEN_PACKET OpenPacket;
ULONG EaErrorOffset;
OPEN_PACKET OpenPacket;
ULONG EaErrorOffset;
TAG_EA);
if(!SystemEaBuffer)
{
TAG_EA);
if(!SystemEaBuffer)
{
- Status = STATUS_INSUFFICIENT_RESOURCES;
- _SEH2_LEAVE;
+ _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES);
}
RtlCopyMemory(SystemEaBuffer, EaBuffer, EaLength);
}
RtlCopyMemory(SystemEaBuffer, EaBuffer, EaLength);
{
DPRINT1("FIXME: IoCheckEaBufferValidity() failed with "
"Status: %lx\n",Status);
{
DPRINT1("FIXME: IoCheckEaBufferValidity() failed with "
"Status: %lx\n",Status);
+
+ /* Free EA Buffer and return the error */
+ ExFreePoolWithTag(SystemEaBuffer, TAG_EA);
+ _SEH2_YIELD(return Status);
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- if(!NT_SUCCESS(Status))
{
/* Free SystemEaBuffer if needed */
if (SystemEaBuffer) ExFreePoolWithTag(SystemEaBuffer, TAG_EA);
{
/* Free SystemEaBuffer if needed */
if (SystemEaBuffer) ExFreePoolWithTag(SystemEaBuffer, TAG_EA);
- /* Return failure status */
- return Status;
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
IN PLARGE_INTEGER TimeOut)
{
MAILSLOT_CREATE_PARAMETERS Buffer;
IN PLARGE_INTEGER TimeOut)
{
MAILSLOT_CREATE_PARAMETERS Buffer;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check for Timeout */
PAGED_CODE();
/* Check for Timeout */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Return the exception */
- if (!NT_SUCCESS(Status)) return Status;
IN PLARGE_INTEGER DefaultTimeout)
{
NAMED_PIPE_CREATE_PARAMETERS Buffer;
IN PLARGE_INTEGER DefaultTimeout)
{
NAMED_PIPE_CREATE_PARAMETERS Buffer;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check for Timeout */
PAGED_CODE();
/* Check for Timeout */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Return the exception */
- if (!NT_SUCCESS(Status)) return Status;
BOOLEAN OurIrpsInList = FALSE;
LARGE_INTEGER Interval;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
BOOLEAN OurIrpsInList = FALSE;
LARGE_INTEGER Interval;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PLIST_ENTRY ListHead, NextEntry;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
PLIST_ENTRY ListHead, NextEntry;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Return exception code on failure */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Reference the file object */
}
/* Reference the file object */
PKQUEUE Queue;
HANDLE hIoCompletionHandle;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PKQUEUE Queue;
HANDLE hIoCompletionHandle;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if this was a user-mode call */
PAGED_CODE();
/* Check if this was a user-mode call */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Create the Object */
}
/* Create the Object */
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
HANDLE hIoCompletionHandle;
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
HANDLE hIoCompletionHandle;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if this was a user-mode call */
PAGED_CODE();
/* Check if this was a user-mode call */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status)) return Status;
{
PKQUEUE Queue;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PKQUEUE Queue;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check buffers and parameters */
PAGED_CODE();
/* Check buffers and parameters */
PIOP_MINI_COMPLETION_PACKET Packet;
PLIST_ENTRY ListEntry;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PIOP_MINI_COMPLETION_PACKET Packet;
PLIST_ENTRY ListEntry;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PIRP Irp;
PVOID Apc, Key;
IO_STATUS_BLOCK IoStatus;
PIRP Irp;
PVOID Apc, Key;
IO_STATUS_BLOCK IoStatus;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status)) return Status;
IN ULONG OutputBufferLength OPTIONAL,
IN BOOLEAN IsDevIoCtl)
{
IN ULONG OutputBufferLength OPTIONAL,
IN BOOLEAN IsDevIoCtl)
{
- NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
PFILE_OBJECT FileObject;
PDEVICE_OBJECT DeviceObject;
PIRP Irp;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
/* Don't check for access rights right now, KernelMode can do anything */
}
/* Don't check for access rights right now, KernelMode can do anything */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
+ /* Cleanup after exception and return */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Cleanup after exception */
+ /* Cleanup after exception and return */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
break;
case METHOD_NEITHER:
break;
case METHOD_NEITHER:
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
PFILE_OBJECT FileObject;
PIRP Irp;
PIO_STACK_LOCATION StackPtr;
- NTSTATUS Status = STATUS_SUCCESS;
PDEVICE_OBJECT DeviceObject;
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
PDEVICE_OBJECT DeviceObject;
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Return exception code, if any */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Get the File Object */
}
/* Get the File Object */
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION IoStack;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION IoStack;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
BOOLEAN LockedForSync = FALSE;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
BOOLEAN LockedForSync = FALSE;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
-
/* Check if CompletionFilter is valid */
if (!CompletionFilter || (CompletionFilter & ~FILE_NOTIFY_VALID_MASK))
{
/* Check if CompletionFilter is valid */
if (!CompletionFilter || (CompletionFilter & ~FILE_NOTIFY_VALID_MASK))
{
BOOLEAN LockedForSync = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
BOOLEAN LockedForSync = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
- NTSTATUS Status = STATUS_SUCCESS;
OBJECT_HANDLE_INFORMATION HandleInformation;
PAGED_CODE();
CapturedByteOffset.QuadPart = 0;
OBJECT_HANDLE_INFORMATION HandleInformation;
PAGED_CODE();
CapturedByteOffset.QuadPart = 0;
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (LocalLength) ExFreePool(LocalLength);
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (LocalLength) ExFreePool(LocalLength);
- /* Get status */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION StackPtr;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION StackPtr;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
BOOLEAN LockedForSynch = FALSE;
PKEVENT Event = NULL;
PVOID AuxBuffer = NULL;
BOOLEAN LockedForSynch = FALSE;
PKEVENT Event = NULL;
PVOID AuxBuffer = NULL;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code and free the buffer */
+ /* Free buffer and return the exception code */
if (AuxBuffer) ExFreePool(AuxBuffer);
if (AuxBuffer) ExFreePool(AuxBuffer);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Return status on failure */
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (AuxBuffer) ExFreePool(AuxBuffer);
IopCleanupAfterException(FileObject, Irp, Event, NULL);
if (AuxBuffer) ExFreePool(AuxBuffer);
- /* Get status */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the buffer and flags */
Irp->UserBuffer = FileInformation;
/* Set the buffer and flags */
Irp->UserBuffer = FileInformation;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, Event, NULL);
IopCleanupAfterException(FileObject, Irp, Event, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
{
OBJECT_HANDLE_INFORMATION HandleInformation;
PFILE_OBJECT FileObject;
{
OBJECT_HANDLE_INFORMATION HandleInformation;
PFILE_OBJECT FileObject;
- NTSTATUS Status = STATUS_SUCCESS;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
- NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Validate User-Mode Buffers */
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
/* Validate User-Mode Buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the buffer and flags */
Irp->UserBuffer = Buffer;
/* Set the buffer and flags */
Irp->UserBuffer = Buffer;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
IN FILE_INFORMATION_CLASS FileInformationClass)
{
PFILE_OBJECT FileObject;
IN FILE_INFORMATION_CLASS FileInformationClass)
{
PFILE_OBJECT FileObject;
- NTSTATUS Status = STATUS_SUCCESS;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PIO_STACK_LOCATION StackPtr;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
/* Set the flags */
Irp->Flags |= (IRP_BUFFERED_IO |
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
LARGE_INTEGER CapturedByteOffset, CapturedLength;
- NTSTATUS Status = STATUS_SUCCESS;
OBJECT_HANDLE_INFORMATION HandleInformation;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
OBJECT_HANDLE_INFORMATION HandleInformation;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
CapturedLength = ProbeForReadLargeInteger(Length);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- /* Check if probing failed */
- if (!NT_SUCCESS(Status))
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
{
/* Dereference the object and return exception code */
ObDereferenceObject(FileObject);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
if (LocalLength) ExFreePool(LocalLength);
IopCleanupAfterException(FileObject, Irp, NULL, Event);
if (LocalLength) ExFreePool(LocalLength);
- /* Get exception status */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
/* Set Parameters */
StackPtr->Parameters.LockControl.ByteOffset = CapturedByteOffset;
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
IN PLARGE_INTEGER ByteOffset OPTIONAL,
IN PULONG Key OPTIONAL)
{
- NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
if (!NT_SUCCESS(Status)) return Status;
/* Validate User-Mode Buffers */
if (!NT_SUCCESS(Status)) return Status;
/* Validate User-Mode Buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Check for probe failure */
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
IopCleanupAfterException(FileObject, Irp, EventObject, NULL);
- Status = _SEH2_GetExceptionCode();
- _SEH2_YIELD(return Status);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO |
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO |
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
PKEVENT Event = NULL;
BOOLEAN LocalEvent = FALSE;
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
IO_STATUS_BLOCK KernelIosb;
PAGED_CODE();
IOTRACE(IO_API_DEBUG, "FileHandle: %p\n", FileHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Allocating failed, clean up */
+ /* Allocating failed, clean up and return the exception code */
IopCleanupAfterException(FileObject, Irp, NULL, Event);
IopCleanupAfterException(FileObject, Irp, NULL, Event);
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
/* Set the flags for this buffered + deferred I/O */
Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
/* Free the IRP and its MDL */
IoFreeMdl(Irp->MdlAddress);
IoFreeIrp(Irp);
/* Free the IRP and its MDL */
IoFreeMdl(Irp->MdlAddress);
IoFreeIrp(Irp);
+
+ /* Fail */
+ _SEH2_YIELD(return NULL);
-
- /* This is how we know if we failed during the probe */
- if (!Irp) return NULL;
/* Free the input buffer and IRP */
if (InputBuffer) ExFreePool(Irp->AssociatedIrp.SystemBuffer);
IoFreeIrp(Irp);
/* Free the input buffer and IRP */
if (InputBuffer) ExFreePool(Irp->AssociatedIrp.SystemBuffer);
IoFreeIrp(Irp);
+
+ /* Fail */
+ _SEH2_YIELD(return NULL);
-
- /* This is how we know if probing failed */
- if (!Irp) return NULL;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ if (Name.Buffer) ExFreePool(Name.Buffer);
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
- if (!NT_SUCCESS(Status) && Name.Buffer)
- {
- ExFreePool(Name.Buffer);
- }
IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
{
PDEVICE_OBJECT DeviceObject = NULL;
IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
{
PDEVICE_OBJECT DeviceObject = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
UNICODE_STRING DeviceInstance;
ULONG BufferSize;
ULONG Property = 0;
UNICODE_STRING DeviceInstance;
ULONG BufferSize;
ULONG Property = 0;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ ExFreePool(DeviceInstance.Buffer);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status))
- {
- ExFreePool(DeviceInstance.Buffer);
- return Status;
- }
-
/* Get the device object */
DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
ExFreePool(DeviceInstance.Buffer);
/* Get the device object */
DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
ExFreePool(DeviceInstance.Buffer);
sizeof(WCHAR));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
sizeof(WCHAR));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- if (!NT_SUCCESS(Status))
{
ExFreePool(TargetDeviceInstance.Buffer);
{
ExFreePool(TargetDeviceInstance.Buffer);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
RtlInitUnicodeString(&RootDeviceName,
L"HTREE\\ROOT\\0");
RtlInitUnicodeString(&RootDeviceName,
L"HTREE\\ROOT\\0");
ULONG DeviceStatus = 0;
ULONG DeviceProblem = 0;
UNICODE_STRING DeviceInstance;
ULONG DeviceStatus = 0;
ULONG DeviceProblem = 0;
UNICODE_STRING DeviceInstance;
- NTSTATUS Status = STATUS_SUCCESS;
DPRINT("IopDeviceStatus() called\n");
DPRINT("IopDeviceStatus() called\n");
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ if (DeviceInstance.Buffer) ExFreePool(DeviceInstance.Buffer);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status))
- {
- if (DeviceInstance.Buffer)
- ExFreePool(DeviceInstance.Buffer);
- return Status;
- }
-
/* Get the device object */
DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
ExFreePool(DeviceInstance.Buffer);
/* Get the device object */
DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
ExFreePool(DeviceInstance.Buffer);
IN OUT PVOID Buffer,
IN ULONG BufferLength)
{
IN OUT PVOID Buffer,
IN ULONG BufferLength)
{
- NTSTATUS Status = STATUS_SUCCESS;
-
DPRINT("NtPlugPlayControl(%lu %p %lu) called\n",
PlugPlayControlClass, Buffer, BufferLength);
DPRINT("NtPlugPlayControl(%lu %p %lu) called\n",
PlugPlayControlClass, Buffer, BufferLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
switch (PlugPlayControlClass)
{
case PlugPlayControlUserResponse:
switch (PlugPlayControlClass)
{
case PlugPlayControlUserResponse:
{
HANDLE Directory;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE Directory;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we need to do any probing */
PAGED_CODE();
/* Check if we need to do any probing */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the error code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Open the directory object */
}
/* Open the directory object */
POBJECT_DIRECTORY Directory;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
ULONG SkipEntries = 0;
POBJECT_DIRECTORY Directory;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
ULONG SkipEntries = 0;
- NTSTATUS Status = STATUS_SUCCESS;
PVOID LocalBuffer;
POBJECT_DIRECTORY_INFORMATION DirectoryInfo;
ULONG Length, TotalLength;
PVOID LocalBuffer;
POBJECT_DIRECTORY_INFORMATION DirectoryInfo;
ULONG Length, TotalLength;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
else if (!RestartScan)
{
}
else if (!RestartScan)
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
POBJECT_DIRECTORY Directory;
HANDLE NewHandle;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
POBJECT_DIRECTORY Directory;
HANDLE NewHandle;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we need to do any probing */
PAGED_CODE();
/* Check if we need to do any probing */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the error code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Create the object */
}
/* Create the object */
PEPROCESS SourceProcess, TargetProcess, Target;
HANDLE hTarget;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PEPROCESS SourceProcess, TargetProcess, Target;
HANDLE hTarget;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
OBTRACE(OB_HANDLE_DEBUG,
"%s - Duplicating handle: %lx for %lx into %lx.\n",
__FUNCTION__,
OBTRACE(OB_HANDLE_DEBUG,
"%s - Duplicating handle: %lx for %lx into %lx.\n",
__FUNCTION__,
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception status */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
/* Now reference the input handle */
}
/* Now reference the input handle */
(ObjectAttributes->Attributes & ~OBJ_VALID_ATTRIBUTES))
{
/* Invalid combination, fail */
(ObjectAttributes->Attributes & ~OBJ_VALID_ATTRIBUTES))
{
/* Invalid combination, fail */
- Status = STATUS_INVALID_PARAMETER;
- _SEH2_LEAVE;
+ _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
}
/* Set some Create Info */
}
/* Set some Create Info */
TRUE,
&ObjectCreateInfo->
SecurityDescriptor);
TRUE,
&ObjectCreateInfo->
SecurityDescriptor);
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
/* Capture failed, quit */
ObjectCreateInfo->SecurityDescriptor = NULL;
{
/* Capture failed, quit */
ObjectCreateInfo->SecurityDescriptor = NULL;
+ _SEH2_YIELD(return Status);
}
/* Save the probe mode and security descriptor size */
}
/* Save the probe mode and security descriptor size */
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
}
_SEH2_EXCEPT(ExSystemExceptionFilter())
{
- /* Get the exception */
- Status = _SEH2_GetExceptionCode();
+ /* Cleanup and return the exception code */
+ ObpReleaseObjectCreateInformation(ObjectCreateInfo);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (NT_SUCCESS(Status))
+ /* Now check if the Object Attributes had an Object Name */
+ if (LocalObjectName)
- /* Now check if the Object Attributes had an Object Name */
- if (LocalObjectName)
- {
- Status = ObpCaptureObjectName(ObjectName,
- LocalObjectName,
- AccessMode,
- AllocateFromLookaside);
- }
- else
- {
- /* Clear the string */
- RtlInitEmptyUnicodeString(ObjectName, NULL, 0);
+ Status = ObpCaptureObjectName(ObjectName,
+ LocalObjectName,
+ AccessMode,
+ AllocateFromLookaside);
+ }
+ else
+ {
+ /* Clear the string */
+ RtlInitEmptyUnicodeString(ObjectName, NULL, 0);
- /* He can't have specified a Root Directory */
- if (ObjectCreateInfo->RootDirectory)
- {
- Status = STATUS_OBJECT_NAME_INVALID;
- }
+ /* He can't have specified a Root Directory */
+ if (ObjectCreateInfo->RootDirectory)
+ {
+ Status = STATUS_OBJECT_NAME_INVALID;
}
}
/* Cleanup if we failed */
if (!NT_SUCCESS(Status))
{
}
}
/* Cleanup if we failed */
if (!NT_SUCCESS(Status))
{
- ObpReleaseObjectCreateInformation(ObjectCreateInfo);
+ ObpReleaseObjectCreateInformation(ObjectCreateInfo);
}
/* Return status to caller */
}
/* Return status to caller */
POBJECT_BASIC_INFORMATION BasicInfo;
ULONG InfoLength;
PVOID Object = NULL;
POBJECT_BASIC_INFORMATION BasicInfo;
ULONG InfoLength;
PVOID Object = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PAGED_CODE();
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PAGED_CODE();
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail if we raised an exception */
- if (!NT_SUCCESS(Status)) return Status;
IN PVOID ObjectInformation,
IN ULONG Length)
{
IN PVOID ObjectInformation,
IN ULONG Length)
{
- NTSTATUS Status = STATUS_SUCCESS;
OBP_SET_HANDLE_ATTRIBUTES_CONTEXT Context;
PVOID ObjectTable;
KAPC_STATE ApcState;
OBP_SET_HANDLE_ATTRIBUTES_CONTEXT Context;
PVOID ObjectTable;
KAPC_STATE ApcState;
return STATUS_INFO_LENGTH_MISMATCH;
}
return STATUS_INFO_LENGTH_MISMATCH;
}
- /* Save the previous mode and actual information */
+ /* Save the previous mode */
Context.PreviousMode = ExGetPreviousMode();
Context.PreviousMode = ExGetPreviousMode();
+ /* Check if we were called from user mode */
if (Context.PreviousMode != KernelMode)
{
if (Context.PreviousMode != KernelMode)
{
+ /* Probe and capture the attribute buffer */
ProbeForRead(ObjectInformation,
sizeof(OBJECT_HANDLE_ATTRIBUTE_INFORMATION),
sizeof(BOOLEAN));
ProbeForRead(ObjectInformation,
sizeof(OBJECT_HANDLE_ATTRIBUTE_INFORMATION),
sizeof(BOOLEAN));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status)) return Status;
+ {
+ /* Just copy the buffer directly */
Context.Information = *(POBJECT_HANDLE_ATTRIBUTE_INFORMATION)
ObjectInformation;
Context.Information = *(POBJECT_HANDLE_ATTRIBUTE_INFORMATION)
ObjectInformation;
/* Check if this is a kernel handle */
if (ObIsKernelHandle(ObjectHandle, Context.PreviousMode))
/* Check if this is a kernel handle */
if (ObIsKernelHandle(ObjectHandle, Context.PreviousMode))
/* Some failure */
Status = STATUS_ACCESS_DENIED;
}
/* Some failure */
Status = STATUS_ACCESS_DENIED;
}
+ else
+ {
+ /* We are done */
+ Status = STATUS_SUCCESS;
+ }
/* De-attach if we were attached, and return status */
if (AttachedToProcess) KeUnstackDetachProcess(&ApcState);
/* De-attach if we were attached, and return status */
if (AttachedToProcess) KeUnstackDetachProcess(&ApcState);
POBJECT_SYMBOLIC_LINK SymbolicLink;
UNICODE_STRING CapturedLinkTarget;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
POBJECT_SYMBOLIC_LINK SymbolicLink;
UNICODE_STRING CapturedLinkTarget;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we need to probe parameters */
PAGED_CODE();
/* Check if we need to probe parameters */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Exception, get the error code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Probing failed, return the error code */
- if(!NT_SUCCESS(Status)) return Status;
{
HANDLE hLink;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
HANDLE hLink;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we need to probe parameters */
PAGED_CODE();
/* Check if we need to probe parameters */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Exception, get the error code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Probing failed, return the error code */
- if(!NT_SUCCESS(Status)) return Status;
UNICODE_STRING SafeLinkTarget = { 0, 0, NULL };
POBJECT_SYMBOLIC_LINK SymlinkObject;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
UNICODE_STRING SafeLinkTarget = { 0, 0, NULL };
POBJECT_SYMBOLIC_LINK SymlinkObject;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
ULONG LengthUsed;
PAGED_CODE();
ULONG LengthUsed;
PAGED_CODE();
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
sizeof(WCHAR));
/* Probe the return length */
sizeof(WCHAR));
/* Probe the return length */
- if(ResultLength) ProbeForWriteUlong(ResultLength);
+ if (ResultLength) ProbeForWriteUlong(ResultLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Probe failure: get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Probe failed, return status */
- if(!NT_SUCCESS(Status)) return Status;
POBJECT_HEADER Header;
POBJECT_TYPE Type;
ACCESS_MASK DesiredAccess;
POBJECT_HEADER Header;
POBJECT_TYPE Type;
ACCESS_MASK DesiredAccess;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if we came from user mode */
PAGED_CODE();
/* Check if we came from user mode */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail if we got an access violation */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Get the required access rights for the operation */
}
/* Get the required access rights for the operation */
PHANDLE_TABLE HandleTable;
ACCESS_MASK GrantedAccess;
PVOID DefaultObject;
PHANDLE_TABLE HandleTable;
ACCESS_MASK GrantedAccess;
PVOID DefaultObject;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Enter a critical region since we'll play with handles */
PAGED_CODE();
/* Enter a critical region since we'll play with handles */
_SEH2_TRY
{
/* Check if the call came from user mode */
_SEH2_TRY
{
/* Check if the call came from user mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
{
/* Check if we have a timeout */
if (TimeOut)
{
/* Check if we have a timeout */
if (TimeOut)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Fail if we raised an exception */
- if (!NT_SUCCESS(Status)) goto Quickie;
-
/* Check if we can use the internal Wait Array */
if (ObjectCount > THREAD_WAIT_OBJECTS)
{
/* Check if we can use the internal Wait Array */
if (ObjectCount > THREAD_WAIT_OBJECTS)
{
PVOID Object, WaitableObject;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LARGE_INTEGER SafeTimeOut;
PVOID Object, WaitableObject;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
LARGE_INTEGER SafeTimeOut;
- NTSTATUS Status = STATUS_SUCCESS;
/* Check if we came with a timeout from user mode */
if ((TimeOut) && (PreviousMode != KernelMode))
/* Check if we came with a timeout from user mode */
if ((TimeOut) && (PreviousMode != KernelMode))
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
PVOID SignalObj, WaitObj, WaitableObject;
LARGE_INTEGER SafeTimeOut;
OBJECT_HANDLE_INFORMATION HandleInfo;
PVOID SignalObj, WaitObj, WaitableObject;
LARGE_INTEGER SafeTimeOut;
OBJECT_HANDLE_INFORMATION HandleInfo;
- NTSTATUS Status = STATUS_SUCCESS;
/* Check if we came with a timeout from user mode */
if ((TimeOut) && (PreviousMode != KernelMode))
/* Check if we came with a timeout from user mode */
if ((TimeOut) && (PreviousMode != KernelMode))
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
/* Start by getting the signal object*/
}
/* Start by getting the signal object*/
{
GET_SET_CTX_CONTEXT GetSetContext;
ULONG Size = 0, Flags = 0;
{
GET_SET_CTX_CONTEXT GetSetContext;
ULONG Size = 0, Flags = 0;
- NTSTATUS Status = STATUS_SUCCESS;
/* Enter SEH */
_SEH2_TRY
/* Enter SEH */
_SEH2_TRY
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Check if we got success */
- if (!NT_SUCCESS(Status)) return Status;
-
/* Initialize the wait event */
KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
/* Initialize the wait event */
KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
/* Leave the guarded region */
KeLeaveGuardedRegion();
/* Leave the guarded region */
KeLeaveGuardedRegion();
+
+ /* We are done */
+ Status = STATUS_SUCCESS;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
{
GET_SET_CTX_CONTEXT GetSetContext;
ULONG Size = 0, Flags = 0;
{
GET_SET_CTX_CONTEXT GetSetContext;
ULONG Size = 0, Flags = 0;
- NTSTATUS Status = STATUS_SUCCESS;
/* Enter SEH */
_SEH2_TRY
/* Enter SEH */
_SEH2_TRY
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Check if we got success */
- if (!NT_SUCCESS(Status)) return Status;
-
/* Initialize the wait event */
KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
/* Initialize the wait event */
KeInitializeEvent(&GetSetContext.Event, NotificationEvent, FALSE);
/* Leave the guarded region */
KeLeaveGuardedRegion();
/* Leave the guarded region */
KeLeaveGuardedRegion();
+
+ /* We are done */
+ Status = STATUS_SUCCESS;
PEJOB Job;
KPROCESSOR_MODE PreviousMode;
PEPROCESS CurrentProcess;
PEJOB Job;
KPROCESSOR_MODE PreviousMode;
PEPROCESS CurrentProcess;
- NTSTATUS Status = STATUS_SUCCESS;
CurrentProcess = PsGetCurrentProcess();
/* check for valid buffers */
CurrentProcess = PsGetCurrentProcess();
/* check for valid buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
}
Status = ObCreateObject(PreviousMode,
}
Status = ObCreateObject(PreviousMode,
{
KPROCESSOR_MODE PreviousMode;
HANDLE hJob;
{
KPROCESSOR_MODE PreviousMode;
HANDLE hJob;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
/* check for valid buffers */
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
/* check for valid buffers */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
+ Status = ObOpenObjectByName(ObjectAttributes,
+ PsJobType,
+ PreviousMode,
+ NULL,
+ DesiredAccess,
+ NULL,
+ &hJob);
- Status = ObOpenObjectByName(ObjectAttributes,
- PsJobType,
- PreviousMode,
- NULL,
- DesiredAccess,
- NULL,
- &hJob);
- if(NT_SUCCESS(Status))
- _SEH2_TRY
- {
- *JobHandle = hJob;
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
IN HANDLE ExceptionPort OPTIONAL,
IN BOOLEAN InJob)
{
IN HANDLE ExceptionPort OPTIONAL,
IN BOOLEAN InJob)
{
- KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
+ KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
+ NTSTATUS Status;
PAGED_CODE();
PSTRACE(PS_PROCESS_DEBUG,
"ParentProcess: %p Flags: %lx\n", ParentProcess, Flags);
/* Check if we came from user mode */
PAGED_CODE();
PSTRACE(PS_PROCESS_DEBUG,
"ParentProcess: %p Flags: %lx\n", ParentProcess, Flags);
/* Check if we came from user mode */
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
/* Make sure there's a parent process */
}
/* Make sure there's a parent process */
BOOLEAN HasObjectName = FALSE;
PETHREAD Thread = NULL;
PEPROCESS Process = NULL;
BOOLEAN HasObjectName = FALSE;
PETHREAD Thread = NULL;
PEPROCESS Process = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
ACCESS_STATE AccessState;
AUX_ACCESS_DATA AuxData;
PAGED_CODE();
ACCESS_STATE AccessState;
AUX_ACCESS_DATA AuxData;
PAGED_CODE();
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
{
PEPROCESS Process;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PEPROCESS Process;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
ULONG Length = 0;
PPROCESS_BASIC_INFORMATION ProcessBasicInfo =
(PPROCESS_BASIC_INFORMATION)ProcessInformation;
ULONG Length = 0;
PPROCESS_BASIC_INFORMATION ProcessBasicInfo =
(PPROCESS_BASIC_INFORMATION)ProcessInformation;
/* Prepare to probe parameters */
_SEH2_TRY
{
/* Prepare to probe parameters */
_SEH2_TRY
{
ProbeForWrite(ProcessInformation,
ProcessInformationLength,
sizeof(ULONG));
ProbeForWrite(ProcessInformation,
ProcessInformationLength,
sizeof(ULONG));
+
+ /* Probe the return length if required */
if (ReturnLength) ProbeForWriteUlong(ReturnLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
if (ReturnLength) ProbeForWriteUlong(ReturnLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the error code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
if((ProcessInformationClass == ProcessCookie) &&
}
if((ProcessInformationClass == ProcessCookie) &&
Length = sizeof(ULONG);
}
Length = sizeof(ULONG);
}
+ /* Indicate success */
+ Status = STATUS_SUCCESS;
+
/* Enter SEH to protect write */
_SEH2_TRY
{
/* Enter SEH to protect write */
_SEH2_TRY
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Get the LPC Port */
Status = ObReferenceObjectByHandle(PortHandle,
/* Get the LPC Port */
Status = ObReferenceObjectByHandle(PortHandle,
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Assign the actual token */
Status = PspSetPrimaryToken(Process, TokenHandle, NULL);
/* Assign the actual token */
Status = PspSetPrimaryToken(Process, TokenHandle, NULL);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Setting the session id requires the SeTcbPrivilege */
if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
/* Setting the session id requires the SeTcbPrivilege */
if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Check for invalid PriorityClass value */
if (PriorityClass.PriorityClass > PROCESS_PRIORITY_CLASS_ABOVE_NORMAL)
/* Check for invalid PriorityClass value */
if (PriorityClass.PriorityClass > PROCESS_PRIORITY_CLASS_ABOVE_NORMAL)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Validate it */
if ((Priority > HIGH_PRIORITY) ||
/* Validate it */
if ((Priority > HIGH_PRIORITY) ||
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Validate it */
if ((Priority > THREAD_BASE_PRIORITY_MAX) ||
/* Validate it */
if ((Priority > THREAD_BASE_PRIORITY_MAX) ||
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Validate it */
if (!Affinity)
/* Validate it */
if (!Affinity)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Assign the actual token */
Status = PsAssignImpersonationToken(Thread, TokenHandle);
/* Assign the actual token */
Status = PsAssignImpersonationToken(Thread, TokenHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Set the address */
Thread->Win32StartAddress = Address;
/* Set the address */
Thread->Win32StartAddress = Address;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Validate it */
if (IdealProcessor > MAXIMUM_PROCESSORS)
/* Validate it */
if (IdealProcessor > MAXIMUM_PROCESSORS)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* Call the kernel */
KeSetDisableBoostThread(&Thread->Tcb, (BOOLEAN)DisableBoost);
/* Call the kernel */
KeSetDisableBoostThread(&Thread->Tcb, (BOOLEAN)DisableBoost);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) break;
/* This is only valid for the current thread */
if (Thread != PsGetCurrentThread())
/* This is only valid for the current thread */
if (Thread != PsGetCurrentThread())
{
PETHREAD Thread;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
{
PETHREAD Thread;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
ULONG Access;
ULONG Length = 0;
PTHREAD_BASIC_INFORMATION ThreadBasicInfo =
ULONG Access;
ULONG Length = 0;
PTHREAD_BASIC_INFORMATION ThreadBasicInfo =
KIRQL OldIrql;
PAGED_CODE();
KIRQL OldIrql;
PAGED_CODE();
+ /* Check if we were called from user mode */
if (PreviousMode != KernelMode)
{
if (PreviousMode != KernelMode)
{
ProbeForWrite(ThreadInformation,
ThreadInformationLength,
sizeof(ULONG));
ProbeForWrite(ThreadInformation,
ThreadInformationLength,
sizeof(ULONG));
- if (ReturnLength)
- {
- ProbeForWriteUlong(ReturnLength);
- }
+ /* Probe the return length if required */
+ if (ReturnLength) ProbeForWriteUlong(ReturnLength);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status)) return Status;
}
/* Check what class this is */
}
/* Check what class this is */
PACCESS_TOKEN Token;
HANDLE hToken;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PACCESS_TOKEN Token;
HANDLE hToken;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PSTRACE(PS_SECURITY_DEBUG,
"Process: %p DesiredAccess: %lx\n", ProcessHandle, DesiredAccess);
PAGED_CODE();
PSTRACE(PS_SECURITY_DEBUG,
"Process: %p DesiredAccess: %lx\n", ProcessHandle, DesiredAccess);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Open the process token */
}
/* Open the process token */
PETHREAD Thread;
PETHREAD ThreadToImpersonate;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETHREAD Thread;
PETHREAD ThreadToImpersonate;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PSTRACE(PS_SECURITY_DEBUG,
"Threads: %p %p\n", ThreadHandle, ThreadToImpersonateHandle);
PAGED_CODE();
PSTRACE(PS_SECURITY_DEBUG,
"Threads: %p %p\n", ThreadHandle, ThreadToImpersonateHandle);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception status */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- /* Fail on exception */
- if (!NT_SUCCESS(Status)) return Status;
}
/* Reference the thread */
}
/* Reference the thread */
PsSuspendThread(IN PETHREAD Thread,
OUT PULONG PreviousCount OPTIONAL)
{
PsSuspendThread(IN PETHREAD Thread,
OUT PULONG PreviousCount OPTIONAL)
{
- NTSTATUS Status = STATUS_SUCCESS;
ULONG OldCount = 0;
PAGED_CODE();
ULONG OldCount = 0;
PAGED_CODE();
{
/* Do the suspend */
OldCount = KeSuspendThread(&Thread->Tcb);
{
/* Do the suspend */
OldCount = KeSuspendThread(&Thread->Tcb);
+
+ /* We are done */
+ Status = STATUS_SUCCESS;
/* Release rundown protection */
ExReleaseRundownProtection(&Thread->RundownProtect);
/* Release rundown protection */
ExReleaseRundownProtection(&Thread->RundownProtect);
+
+ /* We are done */
+ Status = STATUS_SUCCESS;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ /* Get the exception code */
Status = _SEH2_GetExceptionCode();
/* Don't fail if we merely couldn't write the handle back */
Status = _SEH2_GetExceptionCode();
/* Don't fail if we merely couldn't write the handle back */
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETHREAD Thread;
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETHREAD Thread;
- NTSTATUS Status = STATUS_SUCCESS;
ULONG PreviousState;
/* Check if we came from user mode with a suspend count */
ULONG PreviousState;
/* Check if we came from user mode with a suspend count */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
}
/* Reference the Object */
}
/* Reference the Object */
PETHREAD Thread;
ULONG Prev;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETHREAD Thread;
ULONG Prev;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if caller gave a suspend count from user mode */
PAGED_CODE();
/* Check if caller gave a suspend count from user mode */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Get the Thread Object */
}
/* Get the Thread Object */
PETHREAD Thread;
ULONG Prev;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
PETHREAD Thread;
ULONG Prev;
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
/* Check if caller gave a suspend count from user mode */
PAGED_CODE();
/* Check if caller gave a suspend count from user mode */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if(!NT_SUCCESS(Status)) return Status;
}
/* Get the Thread Object */
}
/* Get the Thread Object */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
-
/* Thread insertion failed, thread is dead */
PspSetCrossThreadFlag(Thread, CT_DEAD_THREAD_BIT);
/* Thread insertion failed, thread is dead */
PspSetCrossThreadFlag(Thread, CT_DEAD_THREAD_BIT);
/* Close its handle, killing it */
ObCloseHandle(ThreadHandle, PreviousMode);
/* Close its handle, killing it */
ObCloseHandle(ThreadHandle, PreviousMode);
+
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
IN BOOLEAN CreateSuspended)
{
INITIAL_TEB SafeInitialTeb;
IN BOOLEAN CreateSuspended)
{
INITIAL_TEB SafeInitialTeb;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PSTRACE(PS_THREAD_DEBUG,
"ProcessHandle: %p Context: %p\n", ProcessHandle, ThreadContext);
PAGED_CODE();
PSTRACE(PS_THREAD_DEBUG,
"ProcessHandle: %p Context: %p\n", ProcessHandle, ThreadContext);
ProbeForWriteHandle(ThreadHandle);
/* Check if the caller wants a client id */
ProbeForWriteHandle(ThreadHandle);
/* Check if the caller wants a client id */
{
/* Make sure we can write to it */
ProbeForWrite(ClientId, sizeof(CLIENT_ID), sizeof(ULONG));
{
/* Make sure we can write to it */
ProbeForWrite(ClientId, sizeof(CLIENT_ID), sizeof(ULONG));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
CLIENT_ID SafeClientId;
ULONG Attributes = 0;
HANDLE hThread = NULL;
CLIENT_ID SafeClientId;
ULONG Attributes = 0;
HANDLE hThread = NULL;
- NTSTATUS Status = STATUS_SUCCESS;
PETHREAD Thread;
BOOLEAN HasObjectName = FALSE;
ACCESS_STATE AccessState;
PETHREAD Thread;
BOOLEAN HasObjectName = FALSE;
ACCESS_STATE AccessState;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- if (!NT_SUCCESS(Status)) return Status;
{
PVOID RetResult;
ULONG RetResultLength;
{
PVOID RetResult;
ULONG RetResultLength;
- NTSTATUS Status = STATUS_SUCCESS;
ASSERT(KeGetPreviousMode() != KernelMode);
/* Enter SEH for probing */
ASSERT(KeGetPreviousMode() != KernelMode);
/* Enter SEH for probing */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* Get exception code */
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
- /* Make sure we got success */
+ /* Call kernel function */
+ Status = KeUserModeCallback(RoutineIndex,
+ Argument,
+ ArgumentLength,
+ &RetResult,
+ &RetResultLength);
if (NT_SUCCESS(Status))
{
if (NT_SUCCESS(Status))
{
- /* Call kernel function */
- Status = KeUserModeCallback(RoutineIndex,
- Argument,
- ArgumentLength,
- &RetResult,
- &RetResultLength);
- if (NT_SUCCESS(Status))
+ /* Enter SEH for write back */
+ _SEH2_TRY
+ {
+ /* Return results to user mode */
+ *Result = RetResult;
+ *ResultLength = RetResultLength;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- /* Enter SEH for write back */
- _SEH2_TRY
- {
- /* Return results to user mode */
- *Result = RetResult;
- *ResultLength = RetResultLength;
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- /* Get the exception code */
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ /* Get the exception code */
+ Status = _SEH2_GetExceptionCode();
}
/* Return the result */
}
/* Return the result */
- if(AccessMode != KernelMode)
+ if (AccessMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ NewAcl = ExAllocatePool(PoolType,
+ AclSize);
+ if(NewAcl != NULL)
- NewAcl = ExAllocatePool(PoolType,
- AclSize);
- if(NewAcl != NULL)
- _SEH2_TRY
- {
- RtlCopyMemory(NewAcl,
- InputAcl,
- AclSize);
-
- *CapturedAcl = NewAcl;
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- ExFreePool(NewAcl);
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ RtlCopyMemory(NewAcl,
+ InputAcl,
+ AclSize);
+
+ *CapturedAcl = NewAcl;
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = STATUS_INSUFFICIENT_RESOURCES;
+ /* Free the ACL and return the exception code */
+ ExFreePool(NewAcl);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ _SEH2_END;
+ }
+ else
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
else if(!CaptureIfKernel)
}
}
else if(!CaptureIfKernel)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
}
/* allocate enough memory or check if the provided buffer is
}
/* allocate enough memory or check if the provided buffer is
ULONG Length;
BOOLEAN CheckResult;
KPROCESSOR_MODE PreviousMode;
ULONG Length;
BOOLEAN CheckResult;
KPROCESSOR_MODE PreviousMode;
- NTSTATUS Status = STATUS_SUCCESS;
Privilege[PrivilegeCount]) /
sizeof(RequiredPrivileges->Privilege[0]) != PrivilegeCount)
{
Privilege[PrivilegeCount]) /
sizeof(RequiredPrivileges->Privilege[0]) != PrivilegeCount)
{
- Status = STATUS_INVALID_PARAMETER;
- _SEH2_LEAVE;
+ _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
}
/* probe all of the array */
}
/* probe all of the array */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
ULONG OwnerSize = 0, GroupSize = 0;
ULONG SaclSize = 0, DaclSize = 0;
ULONG DescriptorSize = 0;
ULONG OwnerSize = 0, GroupSize = 0;
ULONG SaclSize = 0, DaclSize = 0;
ULONG DescriptorSize = 0;
- NTSTATUS Status = STATUS_SUCCESS;
if(OriginalSecurityDescriptor != NULL)
{
if(OriginalSecurityDescriptor != NULL)
{
if(OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
if(OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
- Status = STATUS_UNKNOWN_REVISION;
- _SEH2_LEAVE;
+ _SEH2_YIELD(return STATUS_UNKNOWN_REVISION);
}
/* make a copy on the stack */
}
/* make a copy on the stack */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
}
else if(!CaptureIfKernel)
{
}
else if(!CaptureIfKernel)
{
} \
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) \
{ \
} \
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) \
{ \
-Status = _SEH2_GetExceptionCode(); \
+_SEH2_YIELD(return _SEH2_GetExceptionCode()); \
-if(!NT_SUCCESS(Status)) \
-{ \
-return Status; \
-} \
} \
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) \
{ \
} \
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) \
{ \
-Status = _SEH2_GetExceptionCode(); \
+_SEH2_YIELD(return _SEH2_GetExceptionCode()); \
-if(!NT_SUCCESS(Status)) \
-{ \
-return Status; \
-} \
#undef CopyACL
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
#undef CopyACL
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
-
- if(NT_SUCCESS(Status))
- {
- /* we're finally done! copy the pointer to the captured descriptor to
- to the caller */
- *CapturedSecurityDescriptor = NewDescriptor;
- return STATUS_SUCCESS;
- }
- else
{
/* we failed to copy the data to the new descriptor */
ExFreePool(NewDescriptor);
{
/* we failed to copy the data to the new descriptor */
ExFreePool(NewDescriptor);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ _SEH2_END;
+
+ /* we're finally done! copy the pointer to the captured descriptor to
+ to the caller */
+ *CapturedSecurityDescriptor = NewDescriptor;
+ return STATUS_SUCCESS;
+
{
ULONG SidSize = 0;
PISID NewSid, Sid = (PISID)InputSid;
{
ULONG SidSize = 0;
PISID NewSid, Sid = (PISID)InputSid;
- NTSTATUS Status = STATUS_SUCCESS;
- if(AccessMode != KernelMode)
+ if (AccessMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ /* allocate a SID and copy it */
+ NewSid = ExAllocatePool(PoolType,
+ SidSize);
+ if(NewSid != NULL)
- /* allocate a SID and copy it */
- NewSid = ExAllocatePool(PoolType,
- SidSize);
- if(NewSid != NULL)
- _SEH2_TRY
- {
- RtlCopyMemory(NewSid,
- Sid,
- SidSize);
-
- *CapturedSid = NewSid;
- }
- _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- {
- ExFreePool(NewSid);
- Status = _SEH2_GetExceptionCode();
- }
- _SEH2_END;
+ RtlCopyMemory(NewSid,
+ Sid,
+ SidSize);
+
+ *CapturedSid = NewSid;
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
- Status = STATUS_INSUFFICIENT_RESOURCES;
+ /* Free the SID and return the exception code */
+ ExFreePool(NewSid);
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ _SEH2_END;
+ }
+ else
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
else if(!CaptureIfKernel)
}
}
else if(!CaptureIfKernel)
PTOKEN Token;
KPROCESSOR_MODE PreviousMode;
ULONG NeededAccess = TOKEN_ADJUST_DEFAULT;
PTOKEN Token;
KPROCESSOR_MODE PreviousMode;
ULONG NeededAccess = TOKEN_ADJUST_DEFAULT;
- NTSTATUS Status = STATUS_SUCCESS;
if(TokenInformationLength >= sizeof(TOKEN_OWNER))
{
PTOKEN_OWNER to = (PTOKEN_OWNER)TokenInformation;
if(TokenInformationLength >= sizeof(TOKEN_OWNER))
{
PTOKEN_OWNER to = (PTOKEN_OWNER)TokenInformation;
+ PSID InputSid = NULL, CapturedSid;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ Status = SepCaptureSid(InputSid,
+ PreviousMode,
+ PagedPool,
+ FALSE,
+ &CapturedSid);
- PSID CapturedSid;
-
- Status = SepCaptureSid(InputSid,
- PreviousMode,
- PagedPool,
- FALSE,
- &CapturedSid);
- if(NT_SUCCESS(Status))
- {
- RtlCopySid(RtlLengthSid(CapturedSid),
- Token->UserAndGroups[Token->DefaultOwnerIndex].Sid,
- CapturedSid);
- SepReleaseSid(CapturedSid,
- PreviousMode,
- FALSE);
- }
+ RtlCopySid(RtlLengthSid(CapturedSid),
+ Token->UserAndGroups[Token->DefaultOwnerIndex].Sid,
+ CapturedSid);
+ SepReleaseSid(CapturedSid,
+ PreviousMode,
+ FALSE);
if(TokenInformationLength >= sizeof(TOKEN_PRIMARY_GROUP))
{
PTOKEN_PRIMARY_GROUP tpg = (PTOKEN_PRIMARY_GROUP)TokenInformation;
if(TokenInformationLength >= sizeof(TOKEN_PRIMARY_GROUP))
{
PTOKEN_PRIMARY_GROUP tpg = (PTOKEN_PRIMARY_GROUP)TokenInformation;
+ PSID InputSid = NULL, CapturedSid;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ Status = SepCaptureSid(InputSid,
+ PreviousMode,
+ PagedPool,
+ FALSE,
+ &CapturedSid);
- PSID CapturedSid;
-
- Status = SepCaptureSid(InputSid,
- PreviousMode,
- PagedPool,
- FALSE,
- &CapturedSid);
- if(NT_SUCCESS(Status))
- {
- RtlCopySid(RtlLengthSid(CapturedSid),
- Token->PrimaryGroup,
- CapturedSid);
- SepReleaseSid(CapturedSid,
- PreviousMode,
- FALSE);
- }
+ RtlCopySid(RtlLengthSid(CapturedSid),
+ Token->PrimaryGroup,
+ CapturedSid);
+ SepReleaseSid(CapturedSid,
+ PreviousMode,
+ FALSE);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(NT_SUCCESS(Status))
- if(InputAcl != NULL)
- {
- PACL CapturedAcl;
-
- /* capture and copy the dacl */
- Status = SepCaptureAcl(InputAcl,
- PreviousMode,
- PagedPool,
- TRUE,
- &CapturedAcl);
- if(NT_SUCCESS(Status))
- {
- /* free the previous dacl if present */
- if(Token->DefaultDacl != NULL)
- {
- ExFreePool(Token->DefaultDacl);
- }
-
- /* set the new dacl */
- Token->DefaultDacl = CapturedAcl;
- }
- }
- else
+ PACL CapturedAcl;
+
+ /* capture and copy the dacl */
+ Status = SepCaptureAcl(InputAcl,
+ PreviousMode,
+ PagedPool,
+ TRUE,
+ &CapturedAcl);
+ if(NT_SUCCESS(Status))
- /* clear and free the default dacl if present */
+ /* free the previous dacl if present */
if(Token->DefaultDacl != NULL)
{
ExFreePool(Token->DefaultDacl);
if(Token->DefaultDacl != NULL)
{
ExFreePool(Token->DefaultDacl);
- Token->DefaultDacl = NULL;
+
+ /* set the new dacl */
+ Token->DefaultDacl = CapturedAcl;
+ }
+ }
+ else
+ {
+ /* clear and free the default dacl if present */
+ if(Token->DefaultDacl != NULL)
+ {
+ ExFreePool(Token->DefaultDacl);
+ Token->DefaultDacl = NULL;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
+ if(!SeSinglePrivilegeCheck(SeTcbPrivilege,
+ PreviousMode))
- if(!SeSinglePrivilegeCheck(SeTcbPrivilege,
- PreviousMode))
- {
- Status = STATUS_PRIVILEGE_NOT_HELD;
- break;
- }
-
- Token->SessionId = SessionId;
+ Status = STATUS_PRIVILEGE_NOT_HELD;
+ break;
+
+ Token->SessionId = SessionId;
PTOKEN NewToken;
PSECURITY_QUALITY_OF_SERVICE CapturedSecurityQualityOfService;
BOOLEAN QoSPresent;
PTOKEN NewToken;
PSECURITY_QUALITY_OF_SERVICE CapturedSecurityQualityOfService;
BOOLEAN QoSPresent;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PreviousMode = KeGetPreviousMode();
PAGED_CODE();
PreviousMode = KeGetPreviousMode();
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
}
Status = SepCaptureSecurityQualityOfService(ObjectAttributes,
}
Status = SepCaptureSecurityQualityOfService(ObjectAttributes,
KPROCESSOR_MODE PreviousMode;
ULONG nTokenPrivileges = 0;
LARGE_INTEGER LocalExpirationTime = {{0, 0}};
KPROCESSOR_MODE PreviousMode;
ULONG nTokenPrivileges = 0;
LARGE_INTEGER LocalExpirationTime = {{0, 0}};
- NTSTATUS Status = STATUS_SUCCESS;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
SECURITY_DESCRIPTOR SecurityDescriptor;
PACL Dacl = NULL;
KPROCESSOR_MODE PreviousMode;
SECURITY_DESCRIPTOR SecurityDescriptor;
PACL Dacl = NULL;
KPROCESSOR_MODE PreviousMode;
- NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
PAGED_CODE();
PreviousMode = ExGetPreviousMode();
- if(PreviousMode != KernelMode)
+ if (PreviousMode != KernelMode)
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if(!NT_SUCCESS(Status))
- {
- return Status;
- }
KPROCESSOR_MODE PreviousMode;
PTOKEN FirstToken, SecondToken;
BOOLEAN IsEqual;
KPROCESSOR_MODE PreviousMode;
PTOKEN FirstToken, SecondToken;
BOOLEAN IsEqual;
- NTSTATUS Status = STATUS_SUCCESS;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- Status = _SEH2_GetExceptionCode();
+ /* Return the exception code */
+ _SEH2_YIELD(return _SEH2_GetExceptionCode());
-
- if (!NT_SUCCESS(Status))
- return Status;
}
Status = ObReferenceObjectByHandle(FirstTokenHandle,
}
Status = ObReferenceObjectByHandle(FirstTokenHandle,
projects / reactos.git / commitdiff