/**
* 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