#include <k32.h>
#define NDEBUG
-#include "../include/debug.h"
+#include <debug.h>
/* FIXME: NDK */
#define HIGH_PRIORITY 31
/* FUNCTIONS *****************************************************************/
-_SEH_FILTER(BaseThreadExceptionFilter)
+static
+LONG BaseThreadExceptionFilter(EXCEPTION_POINTERS * ExceptionInfo)
{
- EXCEPTION_POINTERS * ExceptionInfo = _SEH_GetExceptionPointers();
LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER;
if (GlobalTopLevelExceptionFilter != NULL)
{
- _SEH_TRY
+ _SEH2_TRY
{
ExceptionDisposition = GlobalTopLevelExceptionFilter(ExceptionInfo);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo);
}
- _SEH_END;
+ _SEH2_END;
}
return ExceptionDisposition;
__declspec(noreturn)
VOID
-STDCALL
+WINAPI
BaseThreadStartup(LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter)
{
volatile UINT uExitCode = 0;
/* Attempt to call the Thread Start Address */
- _SEH_TRY
+ _SEH2_TRY
{
/* Get the exit code from the Thread Start */
uExitCode = (lpStartAddress)((PVOID)lpParameter);
}
- _SEH_EXCEPT(BaseThreadExceptionFilter)
+ _SEH2_EXCEPT(BaseThreadExceptionFilter(_SEH2_GetExceptionInformation()))
{
/* Get the Exit code from the SEH Handler */
- uExitCode = _SEH_GetExceptionCode();
- } _SEH_END;
-
+ uExitCode = _SEH2_GetExceptionCode();
+ } _SEH2_END;
+
/* Exit the Thread */
ExitThread(uExitCode);
}
* @implemented
*/
HANDLE
-STDCALL
+WINAPI
CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
* @implemented
*/
HANDLE
-STDCALL
+WINAPI
CreateRemoteThread(HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
POBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hThread;
ULONG Dummy;
-
+
DPRINT("CreateRemoteThread: hProcess: %ld dwStackSize: %ld lpStartAddress"
- ": %p lpParameter: %lx, dwCreationFlags: %lx\n", hProcess,
+ ": %p lpParameter: %lx, dwCreationFlags: %lx\n", hProcess,
dwStackSize, lpStartAddress, lpParameter, dwCreationFlags);
-
+
/* Clear the Context */
RtlZeroMemory(&Context, sizeof(CONTEXT));
-
+
/* Write PID */
ClientId.UniqueProcess = hProcess;
-
+
/* Create the Stack */
Status = BasepCreateStack(hProcess,
dwStackSize,
dwCreationFlags & STACK_SIZE_PARAM_IS_A_RESERVATION ?
dwStackSize : 0,
- &InitialTeb);
+ &InitialTeb);
if(!NT_SUCCESS(Status))
{
SetLastErrorByStatus(Status);
return NULL;
}
-
+
/* Create Initial Context */
BasepInitializeContext(&Context,
lpParameter,
lpStartAddress,
InitialTeb.StackBase,
1);
-
+
/* initialize the attributes for the thread object */
ObjectAttributes = BasepConvertObjectAttributes(&LocalObjectAttributes,
lpThreadAttributes,
NULL);
-
+
/* Create the Kernel Thread Object */
Status = NtCreateThread(&hThread,
THREAD_ALL_ACCESS,
SetLastErrorByStatus(Status);
return NULL;
}
-
+
#ifdef SXS_SUPPORT_ENABLED
/* Are we in the same process? */
if (Process = NtCurrentProcess())
PTHREAD_BASIC_INFORMATION ThreadBasicInfo;
PACTIVATION_CONTEXT_BASIC_INFORMATION ActivationCtxInfo;
ULONG_PTR Cookie;
-
+
/* Get the TEB */
Status = NtQueryInformationThread(hThread,
ThreadBasicIformation,
&ThreadBasicInfo,
sizeof(ThreadBasicInfo),
NULL);
-
+
/* Allocate the Activation Context Stack */
Status = RtlAllocateActivationContextStack(&ActivationContextStack);
Teb = ThreadBasicInfo.TebBaseAddress;
-
+
/* Save it */
Teb->ActivationContextStackPointer = ActivationContextStack;
-
+
/* Query the Context */
Status = RtlQueryInformationActivationContext(1,
0,
&ActivationCtxInfo,
sizeof(ActivationCtxInfo),
NULL);
-
+
/* Does it need to be activated? */
if (!ActivationCtxInfo.hActCtx)
{
}
}
#endif
-
+
/* FIXME: Notify CSR */
/* Success */
if(lpThreadId) *lpThreadId = (DWORD)ClientId.UniqueThread;
-
+
/* Resume it if asked */
if (!(dwCreationFlags & CREATE_SUSPENDED))
{
NtResumeThread(hThread, &Dummy);
}
-
+
/* Return handle to thread */
return hThread;
}
* @implemented
*/
VOID
-STDCALL
+WINAPI
ExitThread(DWORD uExitCode)
{
NTSTATUS Status;
BOOLEAN LastThread;
-
+
/*
* Terminate process if this is the last thread
* of the current process
/* Notify DLLs and TLS Callbacks of termination */
LdrShutdownThread();
-
+
/* Tell the Kernel to free the Stack */
NtCurrentTeb()->FreeStackOnTermination = TRUE;
NtTerminateThread(NULL, uExitCode);
-
+
/* We will never reach this place. This silences the compiler */
ExitThread(uExitCode);
}
* @implemented
*/
HANDLE
-STDCALL
-OpenThread(
- DWORD dwDesiredAccess,
- BOOL bInheritHandle,
- DWORD dwThreadId
- )
+WINAPI
+OpenThread(DWORD dwDesiredAccess,
+ BOOL bInheritHandle,
+ DWORD dwThreadId)
{
- NTSTATUS errCode;
- HANDLE ThreadHandle;
- OBJECT_ATTRIBUTES ObjectAttributes;
- CLIENT_ID ClientId ;
-
- ClientId.UniqueProcess = 0;
- ClientId.UniqueThread = (HANDLE)dwThreadId;
-
- InitializeObjectAttributes (&ObjectAttributes,
- NULL,
- (bInheritHandle ? OBJ_INHERIT : 0),
- NULL,
- NULL);
+ NTSTATUS errCode;
+ HANDLE ThreadHandle;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ CLIENT_ID ClientId ;
+
+ ClientId.UniqueProcess = 0;
+ ClientId.UniqueThread = (HANDLE)dwThreadId;
+
+ InitializeObjectAttributes(&ObjectAttributes,
+ NULL,
+ (bInheritHandle ? OBJ_INHERIT : 0),
+ NULL,
+ NULL);
+
+ errCode = NtOpenThread(&ThreadHandle,
+ dwDesiredAccess,
+ &ObjectAttributes,
+ &ClientId);
+ if (!NT_SUCCESS(errCode))
+ {
+ SetLastErrorByStatus (errCode);
+ return NULL;
+ }
- errCode = NtOpenThread(&ThreadHandle,
- dwDesiredAccess,
- &ObjectAttributes,
- &ClientId);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus (errCode);
- return NULL;
- }
- return ThreadHandle;
+ return ThreadHandle;
}
-
/*
* @implemented
*/
PTEB
GetTeb(VOID)
{
- return(NtCurrentTeb());
+ return NtCurrentTeb();
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
SwitchToThread(VOID)
{
- NTSTATUS Status;
- Status = NtYieldExecution();
- return Status != STATUS_NO_YIELD_PERFORMED;
+ NTSTATUS Status;
+ Status = NtYieldExecution();
+ return Status != STATUS_NO_YIELD_PERFORMED;
}
/*
* @implemented
*/
-DWORD STDCALL
+DWORD
+WINAPI
GetCurrentThreadId(VOID)
{
- return((DWORD)(NtCurrentTeb()->Cid).UniqueThread);
+ return (DWORD)(NtCurrentTeb()->ClientId).UniqueThread;
}
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+NTAPI
GetThreadTimes(HANDLE hThread,
- LPFILETIME lpCreationTime,
- LPFILETIME lpExitTime,
- LPFILETIME lpKernelTime,
- LPFILETIME lpUserTime)
+ LPFILETIME lpCreationTime,
+ LPFILETIME lpExitTime,
+ LPFILETIME lpKernelTime,
+ LPFILETIME lpUserTime)
{
- KERNEL_USER_TIMES KernelUserTimes;
- NTSTATUS Status;
+ KERNEL_USER_TIMES KernelUserTimes;
+ NTSTATUS Status;
- Status = NtQueryInformationThread(hThread,
- ThreadTimes,
- &KernelUserTimes,
- sizeof(KERNEL_USER_TIMES),
- NULL);
- if (!NT_SUCCESS(Status))
+ Status = NtQueryInformationThread(hThread,
+ ThreadTimes,
+ &KernelUserTimes,
+ sizeof(KERNEL_USER_TIMES),
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return(FALSE);
}
- lpCreationTime->dwLowDateTime = KernelUserTimes.CreateTime.u.LowPart;
- lpCreationTime->dwHighDateTime = KernelUserTimes.CreateTime.u.HighPart;
-
- lpExitTime->dwLowDateTime = KernelUserTimes.ExitTime.u.LowPart;
- lpExitTime->dwHighDateTime = KernelUserTimes.ExitTime.u.HighPart;
-
- lpKernelTime->dwLowDateTime = KernelUserTimes.KernelTime.u.LowPart;
- lpKernelTime->dwHighDateTime = KernelUserTimes.KernelTime.u.HighPart;
-
- lpUserTime->dwLowDateTime = KernelUserTimes.UserTime.u.LowPart;
- lpUserTime->dwHighDateTime = KernelUserTimes.UserTime.u.HighPart;
-
- return(TRUE);
+ *lpCreationTime = *(LPFILETIME)&KernelUserTimes.CreateTime;
+ *lpExitTime = *(LPFILETIME)&KernelUserTimes.ExitTime;
+ *lpKernelTime = *(LPFILETIME)&KernelUserTimes.KernelTime;
+ *lpUserTime = *(LPFILETIME)&KernelUserTimes.UserTime;
+ return TRUE;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
GetThreadContext(HANDLE hThread,
- LPCONTEXT lpContext)
+ LPCONTEXT lpContext)
{
- NTSTATUS Status;
+ NTSTATUS Status;
- Status = NtGetContextThread(hThread,
- lpContext);
- if (!NT_SUCCESS(Status))
+ Status = NtGetContextThread(hThread, lpContext);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
SetThreadContext(HANDLE hThread,
- CONST CONTEXT *lpContext)
+ CONST CONTEXT *lpContext)
{
- NTSTATUS Status;
+ NTSTATUS Status;
- Status = NtSetContextThread(hThread,
- (void *)lpContext);
- if (!NT_SUCCESS(Status))
+ Status = NtSetContextThread(hThread, (PCONTEXT)lpContext);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
GetExitCodeThread(HANDLE hThread,
- LPDWORD lpExitCode)
+ LPDWORD lpExitCode)
{
- THREAD_BASIC_INFORMATION ThreadBasic;
- NTSTATUS Status;
+ THREAD_BASIC_INFORMATION ThreadBasic;
+ NTSTATUS Status;
- Status = NtQueryInformationThread(hThread,
- ThreadBasicInformation,
- &ThreadBasic,
- sizeof(THREAD_BASIC_INFORMATION),
- NULL);
- if (!NT_SUCCESS(Status))
+ Status = NtQueryInformationThread(hThread,
+ ThreadBasicInformation,
+ &ThreadBasic,
+ sizeof(THREAD_BASIC_INFORMATION),
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return(FALSE);
}
- memcpy(lpExitCode, &ThreadBasic.ExitStatus, sizeof(DWORD));
-
- return(TRUE);
+ *lpExitCode = ThreadBasic.ExitStatus;
+ return TRUE;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD
+WINAPI
ResumeThread(HANDLE hThread)
{
- ULONG PreviousResumeCount;
- NTSTATUS Status;
+ ULONG PreviousResumeCount;
+ NTSTATUS Status;
- Status = NtResumeThread(hThread,
- &PreviousResumeCount);
- if (!NT_SUCCESS(Status))
+ Status = NtResumeThread(hThread, &PreviousResumeCount);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(-1);
+ SetLastErrorByStatus(Status);
+ return -1;
}
- return(PreviousResumeCount);
+ return PreviousResumeCount;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
TerminateThread(HANDLE hThread,
- DWORD dwExitCode)
+ DWORD dwExitCode)
{
- NTSTATUS Status;
+ NTSTATUS Status;
- if (0 == hThread)
+ if (!hThread)
{
- SetLastError(ERROR_INVALID_HANDLE);
- return(FALSE);
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
}
- Status = NtTerminateThread(hThread,
- dwExitCode);
- if (!NT_SUCCESS(Status))
+ Status = NtTerminateThread(hThread, dwExitCode);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD
+WINAPI
SuspendThread(HANDLE hThread)
{
- ULONG PreviousSuspendCount;
- NTSTATUS Status;
+ ULONG PreviousSuspendCount;
+ NTSTATUS Status;
- Status = NtSuspendThread(hThread,
- &PreviousSuspendCount);
- if (!NT_SUCCESS(Status))
+ Status = NtSuspendThread(hThread, &PreviousSuspendCount);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(-1);
+ SetLastErrorByStatus(Status);
+ return -1;
}
- return(PreviousSuspendCount);
+ return PreviousSuspendCount;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD_PTR
+WINAPI
SetThreadAffinityMask(HANDLE hThread,
- DWORD dwThreadAffinityMask)
+ DWORD_PTR dwThreadAffinityMask)
{
- THREAD_BASIC_INFORMATION ThreadBasic;
- KAFFINITY AffinityMask;
- NTSTATUS Status;
+ THREAD_BASIC_INFORMATION ThreadBasic;
+ KAFFINITY AffinityMask;
+ NTSTATUS Status;
- AffinityMask = (KAFFINITY)dwThreadAffinityMask;
+ AffinityMask = (KAFFINITY)dwThreadAffinityMask;
- Status = NtQueryInformationThread(hThread,
- ThreadBasicInformation,
- &ThreadBasic,
- sizeof(THREAD_BASIC_INFORMATION),
- NULL);
- if (!NT_SUCCESS(Status))
+ Status = NtQueryInformationThread(hThread,
+ ThreadBasicInformation,
+ &ThreadBasic,
+ sizeof(THREAD_BASIC_INFORMATION),
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(0);
+ SetLastErrorByStatus(Status);
+ return 0;
}
- Status = NtSetInformationThread(hThread,
- ThreadAffinityMask,
- &AffinityMask,
- sizeof(KAFFINITY));
- if (!NT_SUCCESS(Status))
- {
- SetLastErrorByStatus(Status);
- ThreadBasic.AffinityMask = 0;
- }
+ Status = NtSetInformationThread(hThread,
+ ThreadAffinityMask,
+ &AffinityMask,
+ sizeof(KAFFINITY));
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastErrorByStatus(Status);
+ ThreadBasic.AffinityMask = 0;
+ }
- return(ThreadBasic.AffinityMask);
+ return ThreadBasic.AffinityMask;
}
-
/*
* @implemented
*/
BOOL
-STDCALL
+WINAPI
SetThreadPriority(HANDLE hThread,
int nPriority)
{
- ULONG Prio = nPriority;
+ LONG Prio = nPriority;
NTSTATUS Status;
/* Check if values forcing saturation should be used */
Status = NtSetInformationThread(hThread,
ThreadBasePriority,
&Prio,
- sizeof(ULONG));
+ sizeof(LONG));
if (!NT_SUCCESS(Status))
{
/* Failure */
* @implemented
*/
int
-STDCALL
+WINAPI
GetThreadPriority(HANDLE hThread)
{
THREAD_BASIC_INFORMATION ThreadBasic;
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+WINAPI
GetThreadPriorityBoost(IN HANDLE hThread,
- OUT PBOOL pDisablePriorityBoost)
+ OUT PBOOL pDisablePriorityBoost)
{
- ULONG PriorityBoost;
- NTSTATUS Status;
+ ULONG PriorityBoost;
+ NTSTATUS Status;
- Status = NtQueryInformationThread(hThread,
- ThreadPriorityBoost,
- &PriorityBoost,
- sizeof(ULONG),
- NULL);
- if (!NT_SUCCESS(Status))
+ Status = NtQueryInformationThread(hThread,
+ ThreadPriorityBoost,
+ &PriorityBoost,
+ sizeof(ULONG),
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
- *pDisablePriorityBoost = !((BOOL)PriorityBoost);
-
- return(TRUE);
+ *pDisablePriorityBoost = PriorityBoost;
+ return TRUE;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL
+NTAPI
SetThreadPriorityBoost(IN HANDLE hThread,
- IN BOOL bDisablePriorityBoost)
+ IN BOOL bDisablePriorityBoost)
{
- ULONG PriorityBoost;
- NTSTATUS Status;
+ ULONG PriorityBoost;
+ NTSTATUS Status;
- PriorityBoost = (ULONG)!bDisablePriorityBoost;
+ PriorityBoost = (ULONG)bDisablePriorityBoost;
- Status = NtSetInformationThread(hThread,
- ThreadPriorityBoost,
- &PriorityBoost,
- sizeof(ULONG));
- if (!NT_SUCCESS(Status))
+ Status = NtSetInformationThread(hThread,
+ ThreadPriorityBoost,
+ &PriorityBoost,
+ sizeof(ULONG));
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return(FALSE);
+ SetLastErrorByStatus(Status);
+ return FALSE;
}
- return(TRUE);
+ return TRUE;
}
-
/*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetThreadSelectorEntry(IN HANDLE hThread,
IN DWORD dwSelector,
OUT LPLDT_ENTRY lpSelectorEntry)
return TRUE;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD
+WINAPI
SetThreadIdealProcessor(HANDLE hThread,
- DWORD dwIdealProcessor)
+ DWORD dwIdealProcessor)
{
- NTSTATUS Status;
+ NTSTATUS Status;
- Status = NtSetInformationThread(hThread,
- ThreadIdealProcessor,
- &dwIdealProcessor,
- sizeof(ULONG));
- if (!NT_SUCCESS(Status))
+ Status = NtSetInformationThread(hThread,
+ ThreadIdealProcessor,
+ &dwIdealProcessor,
+ sizeof(ULONG));
+ if (!NT_SUCCESS(Status))
{
- SetLastErrorByStatus(Status);
- return -1;
+ SetLastErrorByStatus(Status);
+ return -1;
}
- return dwIdealProcessor;
+ return dwIdealProcessor;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD WINAPI
GetProcessIdOfThread(HANDLE Thread)
{
THREAD_BASIC_INFORMATION ThreadBasic;
return (DWORD)ThreadBasic.ClientId.UniqueProcess;
}
-
/*
* @implemented
*/
-DWORD STDCALL
+DWORD WINAPI
GetThreadId(HANDLE Thread)
{
THREAD_BASIC_INFORMATION ThreadBasic;
/*
* @unimplemented
*/
-LANGID STDCALL
+LANGID WINAPI
SetThreadUILanguage(WORD wReserved)
{
DPRINT1("SetThreadUILanguage(0x%4x) unimplemented!\n", wReserved);
/*
* @implemented
*/
-DWORD STDCALL
+DWORD WINAPI
QueueUserAPC(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData)
{
NTSTATUS Status;
/*
* @implemented
*/
-BOOL STDCALL
+BOOL WINAPI
GetThreadIOPendingFlag(HANDLE hThread,
PBOOL lpIOIsPending)
{
/*
* @implemented
*/
-VOID STDCALL
+VOID WINAPI
Sleep(DWORD dwMilliseconds)
{
SleepEx(dwMilliseconds, FALSE);
/*
* @implemented
*/
-DWORD STDCALL
+DWORD WINAPI
SleepEx(DWORD dwMilliseconds,
BOOL bAlertable)
{
* System time units are 100 nanoseconds (a nanosecond is a billionth of
* a second).
*/
- Interval.QuadPart = -((ULONGLONG)dwMilliseconds * 10000);
+ Interval.QuadPart = -((LONGLONG)dwMilliseconds * 10000);
}
else
{
Interval.QuadPart = -0x7FFFFFFFFFFFFFFFLL;
}
- errCode = NtDelayExecution ((bAlertable ? TRUE : FALSE), &Interval);
- if (!NT_SUCCESS(errCode))
- {
- SetLastErrorByStatus (errCode);
- return -1;
- }
- return 0;
+dowait:
+ errCode = NtDelayExecution ((BOOLEAN)bAlertable, &Interval);
+ if ((bAlertable) && (errCode == STATUS_ALERTED)) goto dowait;
+ return (errCode == STATUS_USER_APC) ? WAIT_IO_COMPLETION : 0;
}
{
QUEUE_USER_WORKITEM_CONTEXT Info;
- ASSERT(Context != NULL);
+ ASSERT(Context);
/* Save the context to the stack */
Info = *(volatile QUEUE_USER_WORKITEM_CONTEXT *)Context;
* @implemented
*/
BOOL
-STDCALL
+WINAPI
QueueUserWorkItem(
LPTHREAD_START_ROUTINE Function,
PVOID Context,
return TRUE;
}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+RegisterWaitForSingleObject(
+ PHANDLE phNewWaitObject,
+ HANDLE hObject,
+ WAITORTIMERCALLBACK Callback,
+ PVOID Context,
+ ULONG dwMilliseconds,
+ ULONG dwFlags
+ )
+{
+ NTSTATUS Status = RtlRegisterWait( phNewWaitObject,
+ hObject,
+ Callback,
+ Context,
+ dwMilliseconds,
+ dwFlags );
+
+ if (Status != STATUS_SUCCESS)
+ {
+ SetLastError( RtlNtStatusToDosError(Status) );
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/*
+ * @implemented
+ */
+HANDLE
+WINAPI
+RegisterWaitForSingleObjectEx(
+ HANDLE hObject,
+ WAITORTIMERCALLBACK Callback,
+ PVOID Context,
+ ULONG dwMilliseconds,
+ ULONG dwFlags
+ )
+{
+ NTSTATUS Status;
+ HANDLE hNewWaitObject;
+
+ Status = RtlRegisterWait( &hNewWaitObject,
+ hObject,
+ Callback,
+ Context,
+ dwMilliseconds,
+ dwFlags );
+
+ if (Status != STATUS_SUCCESS)
+ {
+ SetLastError( RtlNtStatusToDosError(Status) );
+ return NULL;
+ }
+ return hNewWaitObject;
+}
+
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+UnregisterWait(
+ HANDLE WaitHandle
+ )
+{
+ NTSTATUS Status = RtlDeregisterWaitEx( WaitHandle, NULL );
+ if (Status != STATUS_SUCCESS)
+ {
+ SetLastError( RtlNtStatusToDosError(Status) );
+ return FALSE;
+ }
+ return TRUE;
+}
+
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+UnregisterWaitEx(
+ HANDLE WaitHandle,
+ HANDLE CompletionEvent
+ )
+{
+ NTSTATUS Status = RtlDeregisterWaitEx( WaitHandle, CompletionEvent );
+ if (Status != STATUS_SUCCESS)
+ {
+ SetLastError( RtlNtStatusToDosError(Status) );
+ return FALSE;
+ }
+ return TRUE;
+}
+
/* EOF */
projects / reactos.git / blobdiff