/**

 * WinPR: Windows Portable Runtime

 * Windows Native System Services

 *

 * Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 * Copyright 2013 Thincast Technologies GmbH

 * Copyright 2013 Norbert Federa <norbert.federa@thincast.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <winpr/crt.h>

#include <winpr/library.h>

#include <winpr/wlog.h>

#include <winpr/nt.h>

#include <winpr/endian.h>

#include "../log.h"

#define TAG WINPR_TAG("nt")

/**

 * NtXxx Routines:

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff557720/

 */

/**

 * InitializeObjectAttributes macro

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff547804/

 */

VOID _InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,

                                 PUNICODE_STRING ObjectName, ULONG Attributes, HANDLE RootDirectory,

                                 PSECURITY_DESCRIPTOR SecurityDescriptor)

{

#if defined(_WIN32) && !defined(_UWP)

	InitializeObjectAttributes(InitializedAttributes, ObjectName, Attributes, RootDirectory,

	                           SecurityDescriptor);

#else

	InitializedAttributes->Length = sizeof(OBJECT_ATTRIBUTES);

	InitializedAttributes->ObjectName = ObjectName;

	InitializedAttributes->Attributes = Attributes;

	InitializedAttributes->RootDirectory = RootDirectory;

	InitializedAttributes->SecurityDescriptor = SecurityDescriptor;

	InitializedAttributes->SecurityQualityOfService = NULL;

#endif

}

#ifndef _WIN32

#include <pthread.h>

#include <winpr/crt.h>

#include "../handle/handle.h"

struct winpr_nt_file

{

	WINPR_HANDLE_DEF();

	ACCESS_MASK DesiredAccess;

	OBJECT_ATTRIBUTES ObjectAttributes;

	ULONG FileAttributes;

	ULONG ShareAccess;

	ULONG CreateDisposition;

	ULONG CreateOptions;

};

typedef struct winpr_nt_file WINPR_NT_FILE;

static pthread_once_t _TebOnceControl = PTHREAD_ONCE_INIT;

static pthread_key_t _TebKey;

static void _TebDestruct(void* teb)

{

	free(teb);

}

static void _TebInitOnce(void)

{

	pthread_key_create(&_TebKey, _TebDestruct);

}

PTEB NtCurrentTeb(void)

{

	PTEB teb = NULL;

	if (pthread_once(&_TebOnceControl, _TebInitOnce) == 0)

	{

		if ((teb = pthread_getspecific(_TebKey)) == NULL)

		{

			teb = calloc(1, sizeof(TEB));

			if (teb)

				pthread_setspecific(_TebKey, teb);

		}

	}

	return teb;

}

/**

 * RtlInitAnsiString routine:

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff561918/

 */

VOID _RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)

{

	DestinationString->Buffer = (PCHAR)SourceString;

	if (!SourceString)

	{

		DestinationString->Length = 0;

		DestinationString->MaximumLength = 0;

	}

	else

	{

		USHORT length = (USHORT)strlen(SourceString);

		DestinationString->Length = length;

		DestinationString->MaximumLength = length + 1;

	}

}

/**

 * RtlInitUnicodeString routine:

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff561934/

 */

VOID _RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)

{

	DestinationString->Buffer = (PWSTR)SourceString;

	if (!SourceString)

	{

		DestinationString->Length = 0;

		DestinationString->MaximumLength = 0;

	}

	else

	{

		USHORT length = (USHORT)_wcslen(SourceString);

		DestinationString->Length = length * 2;

		DestinationString->MaximumLength = (length + 1) * 2;

	}

}

/**

 * RtlAnsiStringToUnicodeString function:

 * http://msdn.microsoft.com/en-us/library/ms648413/

 */

NTSTATUS _RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString,

                                       PCANSI_STRING SourceString,

                                       BOOLEAN AllocateDestinationString)

{

	int index;

	if (!SourceString)

		return STATUS_INVALID_PARAMETER;

	if (AllocateDestinationString)

	{

		PWSTR wbuf = NULL;

		if (SourceString->MaximumLength)

		{

			if (!(wbuf = (PWSTR)calloc(SourceString->MaximumLength, 2)))

				return STATUS_NO_MEMORY;

		}

		DestinationString->MaximumLength = SourceString->MaximumLength * 2;

		DestinationString->Buffer = wbuf;

	}

	else

	{

		if (DestinationString->MaximumLength < SourceString->MaximumLength * 2)

			return STATUS_BUFFER_OVERFLOW;

	}

	for (index = 0; index < SourceString->MaximumLength; index++)

	{

		Data_Write_UINT16(&DestinationString->Buffer[index], SourceString->Buffer[index]);

	}

	DestinationString->Length = SourceString->Length * 2;

	return STATUS_SUCCESS;

}

/**

 * RtlFreeUnicodeString function:

 * http://msdn.microsoft.com/en-us/library/ms648418/

 */

VOID _RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)

{

	if (UnicodeString)

	{

		free(UnicodeString->Buffer);

		UnicodeString->Length = 0;

		UnicodeString->MaximumLength = 0;

	}

}

/**

 * RtlNtStatusToDosError function:

 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms680600/

 */

ULONG _RtlNtStatusToDosError(NTSTATUS status)

{

	return status;

}

/**

 * NtCreateFile function:

 * http://msdn.microsoft.com/en-us/library/bb432380/

 */

NTSTATUS _NtCreateFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                       POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock,

                       PLARGE_INTEGER AllocationSize, ULONG FileAttributes, ULONG ShareAccess,

                       ULONG CreateDisposition, ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	WINPR_NT_FILE* pFileHandle;

	pFileHandle = (WINPR_NT_FILE*)calloc(1, sizeof(WINPR_NT_FILE));

	if (!pFileHandle)

		return STATUS_NO_MEMORY;

	pFileHandle->DesiredAccess = DesiredAccess;

	pFileHandle->FileAttributes = FileAttributes;

	pFileHandle->ShareAccess = ShareAccess;

	pFileHandle->CreateDisposition = CreateDisposition;

	pFileHandle->CreateOptions = CreateOptions;

	*((PULONG_PTR)FileHandle) = (ULONG_PTR)pFileHandle;

	// STATUS_ACCESS_DENIED

	// STATUS_OBJECT_NAME_INVALID

	// STATUS_OBJECT_PATH_NOT_FOUND

	// STATUS_OBJECT_NAME_NOT_FOUND

	return STATUS_SUCCESS;

#endif

}

/**

 * NtOpenFile function:

 * http://msdn.microsoft.com/en-us/library/bb432381/

 */

NTSTATUS _NtOpenFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                     POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock,

                     ULONG ShareAccess, ULONG OpenOptions)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	WINPR_NT_FILE* pFileHandle;

	pFileHandle = (WINPR_NT_FILE*)calloc(1, sizeof(WINPR_NT_FILE));

	if (!pFileHandle)

		return STATUS_NO_MEMORY;

	pFileHandle->DesiredAccess = DesiredAccess;

	pFileHandle->ShareAccess = ShareAccess;

	*((PULONG_PTR)FileHandle) = (ULONG_PTR)pFileHandle;

	return STATUS_SUCCESS;

#endif

}

/**

 * NtReadFile function:

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff567072/

 */

NTSTATUS _NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                     PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length,

                     PLARGE_INTEGER ByteOffset, PULONG Key)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	return STATUS_SUCCESS;

#endif

}

/**

 * NtWriteFile function:

 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff567121/

 */

NTSTATUS _NtWriteFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                      PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length,

                      PLARGE_INTEGER ByteOffset, PULONG Key)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	return STATUS_SUCCESS;

#endif

}

/**

 * NtDeviceIoControlFile function:

 * http://msdn.microsoft.com/en-us/library/ms648411/

 */

NTSTATUS _NtDeviceIoControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine,

                                PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock,

                                ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength,

                                PVOID OutputBuffer, ULONG OutputBufferLength)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	return STATUS_SUCCESS;

#endif

}

/**

 * NtClose function:

 * http://msdn.microsoft.com/en-us/library/ms648410/

 */

NTSTATUS _NtClose(HANDLE Handle)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	WINPR_NT_FILE* pFileHandle;

	if (!Handle)

		return STATUS_SUCCESS;

	pFileHandle = (WINPR_NT_FILE*)Handle;

	free(pFileHandle);

	return STATUS_SUCCESS;

#endif

}

/**

 * NtWaitForSingleObject function:

 * http://msdn.microsoft.com/en-us/library/ms648412/

 */

NTSTATUS _NtWaitForSingleObject(HANDLE Handle, BOOLEAN Alertable, PLARGE_INTEGER Timeout)

{

#if 1

	WLog_ERR(TAG, "%s: Not implemented", __FUNCTION__);

	return STATUS_NOT_SUPPORTED;

#else

	return STATUS_SUCCESS;

#endif

}

#else

#include <winpr/synch.h>

typedef VOID(WINAPI* RTL_INIT_ANSI_STRING_FN)(PANSI_STRING DestinationString, PCSZ SourceString);

typedef VOID(WINAPI* RTL_INIT_UNICODE_STRING_FN)(PUNICODE_STRING DestinationString,

                                                 PCWSTR SourceString);

typedef NTSTATUS(WINAPI* RTL_ANSI_STRING_TO_UNICODE_STRING_FN)(PUNICODE_STRING DestinationString,

                                                               PCANSI_STRING SourceString,

                                                               BOOLEAN AllocateDestinationString);

typedef VOID(WINAPI* RTL_FREE_UNICODE_STRING_FN)(PUNICODE_STRING UnicodeString);

typedef ULONG(WINAPI* RTL_NT_STATUS_TO_DOS_ERROR_FN)(NTSTATUS status);

typedef NTSTATUS(WINAPI* NT_CREATE_FILE_FN)(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                                            POBJECT_ATTRIBUTES ObjectAttributes,

                                            PIO_STATUS_BLOCK IoStatusBlock,

                                            PLARGE_INTEGER AllocationSize, ULONG FileAttributes,

                                            ULONG ShareAccess, ULONG CreateDisposition,

                                            ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength);

typedef NTSTATUS(WINAPI* NT_OPEN_FILE_FN)(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                                          POBJECT_ATTRIBUTES ObjectAttributes,

                                          PIO_STATUS_BLOCK IoStatusBlock, ULONG ShareAccess,

                                          ULONG OpenOptions);

typedef NTSTATUS(WINAPI* NT_READ_FILE_FN)(HANDLE FileHandle, HANDLE Event,

                                          PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                                          PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer,

                                          ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key);

typedef NTSTATUS(WINAPI* NT_WRITE_FILE_FN)(HANDLE FileHandle, HANDLE Event,

                                           PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                                           PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer,

                                           ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key);

typedef NTSTATUS(WINAPI* NT_DEVICE_IO_CONTROL_FILE_FN)(HANDLE FileHandle, HANDLE Event,

                                                       PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                                                       PIO_STATUS_BLOCK IoStatusBlock,

                                                       ULONG IoControlCode, PVOID InputBuffer,

                                                       ULONG InputBufferLength, PVOID OutputBuffer,

                                                       ULONG OutputBufferLength);

typedef NTSTATUS(WINAPI* NT_CLOSE_FN)(HANDLE Handle);

typedef NTSTATUS(WINAPI* NT_WAIT_FOR_SINGLE_OBJECT_FN)(HANDLE Handle, BOOLEAN Alertable,

                                                       PLARGE_INTEGER Timeout);

static RTL_INIT_ANSI_STRING_FN pRtlInitAnsiString = NULL;

static RTL_INIT_UNICODE_STRING_FN pRtlInitUnicodeString = NULL;

static RTL_ANSI_STRING_TO_UNICODE_STRING_FN pRtlAnsiStringToUnicodeString = NULL;

static RTL_FREE_UNICODE_STRING_FN pRtlFreeUnicodeString = NULL;

static RTL_NT_STATUS_TO_DOS_ERROR_FN pRtlNtStatusToDosError = NULL;

static NT_CREATE_FILE_FN pNtCreateFile = NULL;

static NT_OPEN_FILE_FN pNtOpenFile = NULL;

static NT_READ_FILE_FN pNtReadFile = NULL;

static NT_WRITE_FILE_FN pNtWriteFile = NULL;

static NT_DEVICE_IO_CONTROL_FILE_FN pNtDeviceIoControlFile = NULL;

static NT_CLOSE_FN pNtClose = NULL;

static NT_WAIT_FOR_SINGLE_OBJECT_FN pNtWaitForSingleObject = NULL;

static INIT_ONCE ntdllInitOnce = INIT_ONCE_STATIC_INIT;

static BOOL CALLBACK NtdllModuleInit(PINIT_ONCE once, PVOID param, PVOID* context)

{

	HMODULE NtdllModule = LoadLibraryA("ntdll.dll");

	if (NtdllModule)

	{

		pRtlInitAnsiString =

		    (RTL_INIT_ANSI_STRING_FN)GetProcAddress(NtdllModule, "RtlInitAnsiString");

		pRtlInitUnicodeString =

		    (RTL_INIT_UNICODE_STRING_FN)GetProcAddress(NtdllModule, "RtlInitUnicodeString");

		pRtlAnsiStringToUnicodeString = (RTL_ANSI_STRING_TO_UNICODE_STRING_FN)GetProcAddress(

		    NtdllModule, "RtlAnsiStringToUnicodeString");

		pRtlFreeUnicodeString =

		    (RTL_FREE_UNICODE_STRING_FN)GetProcAddress(NtdllModule, "RtlFreeUnicodeString");

		pRtlNtStatusToDosError =

		    (RTL_NT_STATUS_TO_DOS_ERROR_FN)GetProcAddress(NtdllModule, "RtlNtStatusToDosError");

		pNtCreateFile = (NT_CREATE_FILE_FN)GetProcAddress(NtdllModule, "NtCreateFile");

		pNtOpenFile = (NT_OPEN_FILE_FN)GetProcAddress(NtdllModule, "NtOpenFile");

		pNtReadFile = (NT_READ_FILE_FN)GetProcAddress(NtdllModule, "NtReadFile");

		pNtWriteFile = (NT_WRITE_FILE_FN)GetProcAddress(NtdllModule, "NtWriteFile");

		pNtDeviceIoControlFile =

		    (NT_DEVICE_IO_CONTROL_FILE_FN)GetProcAddress(NtdllModule, "NtDeviceIoControlFile");

		pNtClose = (NT_CLOSE_FN)GetProcAddress(NtdllModule, "NtClose");

		pNtWaitForSingleObject =

		    (NT_WAIT_FOR_SINGLE_OBJECT_FN)GetProcAddress(NtdllModule, "NtWaitForSingleObject");

	}

	return TRUE;

}

VOID _RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pRtlInitAnsiString)

		return;

	pRtlInitAnsiString(DestinationString, SourceString);

}

VOID _RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pRtlInitUnicodeString)

		return;

	pRtlInitUnicodeString(DestinationString, SourceString);

}

NTSTATUS _RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString,

                                       PCANSI_STRING SourceString,

                                       BOOLEAN AllocateDestinationString)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pRtlAnsiStringToUnicodeString)

		return STATUS_INTERNAL_ERROR;

	return pRtlAnsiStringToUnicodeString(DestinationString, SourceString,

	                                     AllocateDestinationString);

}

VOID _RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pRtlFreeUnicodeString)

		return;

	pRtlFreeUnicodeString(UnicodeString);

}

ULONG _RtlNtStatusToDosError(NTSTATUS status)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pRtlNtStatusToDosError)

		return status;

	return pRtlNtStatusToDosError(status);

}

NTSTATUS _NtCreateFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                       POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock,

                       PLARGE_INTEGER AllocationSize, ULONG FileAttributes, ULONG ShareAccess,

                       ULONG CreateDisposition, ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtCreateFile)

		return STATUS_INTERNAL_ERROR;

	return pNtCreateFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, AllocationSize,

	                     FileAttributes, ShareAccess, CreateDisposition, CreateOptions, EaBuffer,

	                     EaLength);

}

NTSTATUS _NtOpenFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess,

                     POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock,

                     ULONG ShareAccess, ULONG OpenOptions)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtOpenFile)

		return STATUS_INTERNAL_ERROR;

	return pNtOpenFile(FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock, ShareAccess,

	                   OpenOptions);

}

NTSTATUS _NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                     PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length,

                     PLARGE_INTEGER ByteOffset, PULONG Key)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtReadFile)

		return STATUS_INTERNAL_ERROR;

	return pNtReadFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, Buffer, Length,

	                   ByteOffset, Key);

}

NTSTATUS _NtWriteFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,

                      PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length,

                      PLARGE_INTEGER ByteOffset, PULONG Key)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtWriteFile)

		return STATUS_INTERNAL_ERROR;

	return pNtWriteFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, Buffer, Length,

	                    ByteOffset, Key);

}

NTSTATUS _NtDeviceIoControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine,

                                PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock,

                                ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength,

                                PVOID OutputBuffer, ULONG OutputBufferLength)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtDeviceIoControlFile)

		return STATUS_INTERNAL_ERROR;

	return pNtDeviceIoControlFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,

	                              IoControlCode, InputBuffer, InputBufferLength, OutputBuffer,

	                              OutputBufferLength);

}

NTSTATUS _NtClose(HANDLE Handle)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtClose)

		return STATUS_INTERNAL_ERROR;

	return pNtClose(Handle);

}

NTSTATUS _NtWaitForSingleObject(HANDLE Handle, BOOLEAN Alertable, PLARGE_INTEGER Timeout)

{

	InitOnceExecuteOnce(&ntdllInitOnce, NtdllModuleInit, NULL, NULL);

	if (!pNtWaitForSingleObject)

		return STATUS_INTERNAL_ERROR;

	return pNtWaitForSingleObject(Handle, Alertable, Timeout);

}

#endif