/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Server Channels

 *

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

 * Copyright 2015 Thincast Technologies GmbH

 * Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@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 <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <winpr/crt.h>

#include <winpr/synch.h>

#include <winpr/stream.h>

#include <freerdp/log.h>

#include <freerdp/constants.h>

#include <freerdp/server/channels.h>

#include "rdp.h"

#include "server.h"

#define TAG FREERDP_TAG("core.server")

#ifdef WITH_DEBUG_DVC

#define DEBUG_DVC(...) WLog_DBG(TAG, __VA_ARGS__)

#else

#define DEBUG_DVC(...) do { } while (0)

#endif

struct _wtsChannelMessage

{

	UINT16 channelId;

	UINT16 reserved;

	UINT32 length;

	UINT32 offset;

};

typedef struct _wtsChannelMessage wtsChannelMessage;

static DWORD g_SessionId = 1;

static wHashTable* g_ServerHandles = NULL;

static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm,

        UINT32 ChannelId)

{

	int index;

	int count;

	BOOL found = FALSE;

	rdpPeerChannel* channel = NULL;

	ArrayList_Lock(vcm->dynamicVirtualChannels);

	count = ArrayList_Count(vcm->dynamicVirtualChannels);

	for (index = 0; index < count; index++)

	{

		channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels,

		          index);

		if (channel->channelId == ChannelId)

		{

			found = TRUE;

			break;

		}

	}

	ArrayList_Unlock(vcm->dynamicVirtualChannels);

	return found ? channel : NULL;

}

static BOOL wts_queue_receive_data(rdpPeerChannel* channel, const BYTE* Buffer,

                                   UINT32 Length)

{

	BYTE* buffer;

	wtsChannelMessage* messageCtx;

	messageCtx = (wtsChannelMessage*) malloc(sizeof(wtsChannelMessage) + Length);

	if (!messageCtx)

		return FALSE;

	messageCtx->channelId = channel->channelId;

	messageCtx->length = Length;

	messageCtx->offset = 0;

	buffer = (BYTE*)(messageCtx + 1);

	CopyMemory(buffer, Buffer, Length);

	return MessageQueue_Post(channel->queue, messageCtx, 0, NULL, NULL);

}

static BOOL wts_queue_send_item(rdpPeerChannel* channel, BYTE* Buffer,

                                UINT32 Length)

{

	BYTE* buffer;

	UINT32 length;

	UINT16 channelId;

	buffer = Buffer;

	length = Length;

	channelId = channel->channelId;

	return MessageQueue_Post(channel->vcm->queue, (void*)(UINT_PTR) channelId, 0,

	                         (void*) buffer, (void*)(UINT_PTR) length);

}

static int wts_read_variable_uint(wStream* s, int cbLen, UINT32* val)

{

	switch (cbLen)

	{

		case 0:

			if (Stream_GetRemainingLength(s) < 1)

				return 0;

			Stream_Read_UINT8(s, *val);

			return 1;

		case 1:

			if (Stream_GetRemainingLength(s) < 2)

				return 0;

			Stream_Read_UINT16(s, *val);

			return 2;

		default:

			if (Stream_GetRemainingLength(s) < 4)

				return 0;

			Stream_Read_UINT32(s, *val);

			return 4;

	}

}

static BOOL wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel,

        UINT32 length)

{

	UINT16 Version;

	if (length < 3)

		return FALSE;

	Stream_Seek_UINT8(channel->receiveData); /* Pad (1 byte) */

	Stream_Read_UINT16(channel->receiveData, Version);

	DEBUG_DVC("Version: %"PRIu16"", Version);

	channel->vcm->drdynvc_state = DRDYNVC_STATE_READY;

	return TRUE;

}

static BOOL wts_read_drdynvc_create_response(rdpPeerChannel* channel,

        wStream* s, UINT32 length)

{

	UINT32 CreationStatus;

	if (length < 4)

		return FALSE;

	Stream_Read_UINT32(s, CreationStatus);

	if ((INT32) CreationStatus < 0)

	{

		DEBUG_DVC("ChannelId %"PRIu32" creation failed (%"PRId32")", channel->channelId,

		          (INT32) CreationStatus);

		channel->dvc_open_state = DVC_OPEN_STATE_FAILED;

	}

	else

	{

		DEBUG_DVC("ChannelId %"PRIu32" creation succeeded", channel->channelId);

		channel->dvc_open_state = DVC_OPEN_STATE_SUCCEEDED;

	}

	return TRUE;

}

static BOOL wts_read_drdynvc_data_first(rdpPeerChannel* channel, wStream* s,

                                        int cbLen, UINT32 length)

{

	int value;

	value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);

	if (value == 0)

		return FALSE;

	length -= value;

	if (length > channel->dvc_total_length)

		return FALSE;

	Stream_SetPosition(channel->receiveData, 0);

	if (!Stream_EnsureRemainingCapacity(channel->receiveData,

	                                    (int) channel->dvc_total_length))

		return FALSE;

	Stream_Write(channel->receiveData, Stream_Pointer(s), length);

	return TRUE;

}

static BOOL wts_read_drdynvc_data(rdpPeerChannel* channel, wStream* s,

                                  UINT32 length)

{

	BOOL ret = FALSE;

	if (channel->dvc_total_length > 0)

	{

		if (Stream_GetPosition(channel->receiveData) + length >

		    channel->dvc_total_length)

		{

			channel->dvc_total_length = 0;

			WLog_ERR(TAG, "incorrect fragment data, discarded.");

			return FALSE;

		}

		Stream_Write(channel->receiveData, Stream_Pointer(s), length);

		if (Stream_GetPosition(channel->receiveData) >= (int) channel->dvc_total_length)

		{

			ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),

			                             channel->dvc_total_length);

			channel->dvc_total_length = 0;

		}

	}

	else

	{

		ret = wts_queue_receive_data(channel, Stream_Pointer(s), length);

	}

	return ret;

}

static void wts_read_drdynvc_close_response(rdpPeerChannel* channel)

{

	DEBUG_DVC("ChannelId %"PRIu32" close response", channel->channelId);

	channel->dvc_open_state = DVC_OPEN_STATE_CLOSED;

}

static BOOL wts_read_drdynvc_pdu(rdpPeerChannel* channel)

{

	UINT32 length;

	int value;

	int Cmd;

	int Sp;

	int cbChId;

	UINT32 ChannelId;

	rdpPeerChannel* dvc;

	length = Stream_GetPosition(channel->receiveData);

	if (length < 1)

		return FALSE;

	Stream_SetPosition(channel->receiveData, 0);

	Stream_Read_UINT8(channel->receiveData, value);

	length--;

	Cmd = (value & 0xf0) >> 4;

	Sp = (value & 0x0c) >> 2;

	cbChId = (value & 0x03) >> 0;

	if (Cmd == CAPABILITY_REQUEST_PDU)

	{

		return wts_read_drdynvc_capabilities_response(channel, length);

	}

	else if (channel->vcm->drdynvc_state == DRDYNVC_STATE_READY)

	{

		value = wts_read_variable_uint(channel->receiveData, cbChId, &ChannelId);

		if (value == 0)

			return FALSE;

		length -= value;

		DEBUG_DVC("Cmd %d ChannelId %"PRIu32" length %"PRIu32"", Cmd, ChannelId, length);

		dvc = wts_get_dvc_channel_by_id(channel->vcm, ChannelId);

		if (dvc)

		{

			switch (Cmd)

			{

				case CREATE_REQUEST_PDU:

					return wts_read_drdynvc_create_response(dvc, channel->receiveData, length);

				case DATA_FIRST_PDU:

					return wts_read_drdynvc_data_first(dvc, channel->receiveData, Sp, length);

				case DATA_PDU:

					return wts_read_drdynvc_data(dvc, channel->receiveData, length);

				case CLOSE_REQUEST_PDU:

					wts_read_drdynvc_close_response(dvc);

					break;

				default:

					WLog_ERR(TAG,  "Cmd %d not recognized.", Cmd);

					break;

			}

		}

		else

		{

			DEBUG_DVC("ChannelId %"PRIu32" not exists.", ChannelId);

		}

	}

	else

	{

		WLog_ERR(TAG,  "received Cmd %d but channel is not ready.", Cmd);

	}

	return TRUE;

}

static int wts_write_variable_uint(wStream* s, UINT32 val)

{

	int cb;

	if (val <= 0xFF)

	{

		cb = 0;

		Stream_Write_UINT8(s, val);

	}

	else if (val <= 0xFFFF)

	{

		cb = 1;

		Stream_Write_UINT16(s, val);

	}

	else

	{

		cb = 2;

		Stream_Write_UINT32(s, val);

	}

	return cb;

}

static void wts_write_drdynvc_header(wStream* s, BYTE Cmd, UINT32 ChannelId)

{

	BYTE* bm;

	int cbChId;

	Stream_GetPointer(s, bm);

	Stream_Seek_UINT8(s);

	cbChId = wts_write_variable_uint(s, ChannelId);

	*bm = ((Cmd & 0x0F) << 4) | cbChId;

}

static BOOL wts_write_drdynvc_create_request(wStream* s, UINT32 ChannelId,

        const char* ChannelName)

{

	UINT32 len;

	wts_write_drdynvc_header(s, CREATE_REQUEST_PDU, ChannelId);

	len = strlen(ChannelName) + 1;

	if (!Stream_EnsureRemainingCapacity(s, (int) len))

		return FALSE;

	Stream_Write(s, ChannelName, len);

	return TRUE;

}

static BOOL WTSProcessChannelData(rdpPeerChannel* channel, UINT16 channelId,

                                  const BYTE* data, int size, int flags, int totalSize)

{

	BOOL ret = TRUE;

	if (flags & CHANNEL_FLAG_FIRST)

	{

		Stream_SetPosition(channel->receiveData, 0);

	}

	if (!Stream_EnsureRemainingCapacity(channel->receiveData, size))

		return FALSE;

	Stream_Write(channel->receiveData, data, size);

	if (flags & CHANNEL_FLAG_LAST)

	{

		if (Stream_GetPosition(channel->receiveData) != totalSize)

		{

			WLog_ERR(TAG, "read error");

		}

		if (channel == channel->vcm->drdynvc_channel)

		{

			ret = wts_read_drdynvc_pdu(channel);

		}

		else

		{

			ret = wts_queue_receive_data(channel, Stream_Buffer(channel->receiveData),

			                             Stream_GetPosition(channel->receiveData));

		}

		Stream_SetPosition(channel->receiveData, 0);

	}

	return ret;

}

static int WTSReceiveChannelData(freerdp_peer* client, UINT16 channelId,

                                 const BYTE* data, int size, int flags, int totalSize)

{

	UINT32 i;

	BOOL status = FALSE;

	rdpPeerChannel* channel;

	rdpMcs* mcs = client->context->rdp->mcs;

	for (i = 0; i < mcs->channelCount; i++)

	{

		if (mcs->channels[i].ChannelId == channelId)

			break;

	}

	if (i < mcs->channelCount)

	{

		channel = (rdpPeerChannel*) mcs->channels[i].handle;

		if (channel)

		{

			WTSProcessChannelData(channel, channelId, data, size, flags, totalSize);

			status = TRUE;

		}

	}

	return status;

}

void WTSVirtualChannelManagerGetFileDescriptor(HANDLE hServer, void** fds,

        int* fds_count)

{

	void* fd;

	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*) hServer;

	fd = GetEventWaitObject(MessageQueue_Event(vcm->queue));

	if (fd)

	{

		fds[*fds_count] = fd;

		(*fds_count)++;

	}

#if 0

	if (vcm->drdynvc_channel)

	{

		fd = GetEventWaitObject(vcm->drdynvc_channel->receiveEvent);

		if (fd)

		{

			fds[*fds_count] = fd;

			(*fds_count)++;

		}

	}

#endif

}

BOOL WTSVirtualChannelManagerCheckFileDescriptor(HANDLE hServer)

{

	wMessage message;

	BOOL status = TRUE;

	rdpPeerChannel* channel;

	UINT32 dynvc_caps;

	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*) hServer;

	if ((vcm->drdynvc_state == DRDYNVC_STATE_NONE) && vcm->client->activated)

	{

		/* Initialize drdynvc channel once and only once. */

		vcm->drdynvc_state = DRDYNVC_STATE_INITIALIZED;

		channel = (rdpPeerChannel*) WTSVirtualChannelOpen((HANDLE) vcm,

		          WTS_CURRENT_SESSION, "drdynvc");

		if (channel)

		{

			ULONG written;

			vcm->drdynvc_channel = channel;

			dynvc_caps = 0x00010050; /* DYNVC_CAPS_VERSION1 (4 bytes) */

			if (!WTSVirtualChannelWrite(channel, (PCHAR) &dynvc_caps, sizeof(dynvc_caps),

			                            &written))

				return FALSE;

		}

	}

	while (MessageQueue_Peek(vcm->queue, &message, TRUE))

	{

		BYTE* buffer;

		UINT32 length;

		UINT16 channelId;

		channelId = (UINT16)(UINT_PTR) message.context;

		buffer = (BYTE*) message.wParam;

		length = (UINT32)(UINT_PTR) message.lParam;

		if (vcm->client->SendChannelData(vcm->client, channelId, buffer,

		                                 length) == FALSE)

		{

			status = FALSE;

		}

		free(buffer);

		if (!status)

			break;

	}

	return status;

}

HANDLE WTSVirtualChannelManagerGetEventHandle(HANDLE hServer)

{

	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*) hServer;

	return MessageQueue_Event(vcm->queue);

}

static rdpMcsChannel* wts_get_joined_channel_by_name(rdpMcs* mcs,

        const char* channel_name)

{

	UINT32 index;

	if (!mcs || !channel_name || !strlen(channel_name))

		return NULL;

	for (index = 0; index < mcs->channelCount; index++)

	{

		if (mcs->channels[index].joined)

		{

			if (_strnicmp(mcs->channels[index].Name, channel_name,

			              strlen(channel_name)) == 0)

				return &mcs->channels[index];

		}

	}

	return NULL;

}

static rdpMcsChannel* wts_get_joined_channel_by_id(rdpMcs* mcs,

        const UINT16 channel_id)

{

	UINT32 index;

	if (!mcs || !channel_id)

		return NULL;

	for (index = 0; index < mcs->channelCount; index++)

	{

		if (mcs->channels[index].joined)

		{

			if (mcs->channels[index].ChannelId == channel_id)

				return &mcs->channels[index];

		}

	}

	return NULL;

}

BOOL WTSIsChannelJoinedByName(freerdp_peer* client, const char* channel_name)

{

	if (!client || !client->context || !client->context->rdp)

		return FALSE;

	return wts_get_joined_channel_by_name(client->context->rdp->mcs,

	                                      channel_name) == NULL ? FALSE : TRUE;

}

BOOL WTSIsChannelJoinedById(freerdp_peer* client, const UINT16 channel_id)

{

	if (!client || !client->context || !client->context->rdp)

		return FALSE;

	return wts_get_joined_channel_by_id(client->context->rdp->mcs,

	                                    channel_id) == NULL ? FALSE : TRUE;

}

BOOL WTSVirtualChannelManagerIsChannelJoined(HANDLE hServer, const char* name)

{

	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*) hServer;

	if (!vcm || !vcm->rdp)

		return FALSE;

	return wts_get_joined_channel_by_name(vcm->rdp->mcs,

	                                      name) == NULL ? FALSE : TRUE;

}

BYTE WTSVirtualChannelManagerGetDrdynvcState(HANDLE hServer)

{

	WTSVirtualChannelManager* vcm = (WTSVirtualChannelManager*) hServer;

	return vcm->drdynvc_state;

}

UINT16 WTSChannelGetId(freerdp_peer* client, const char* channel_name)

{

	rdpMcsChannel* channel;

	if (!client || !client->context || !client->context->rdp)

		return 0;

	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs,

	          channel_name);

	if (!channel)

		return 0;

	return channel->ChannelId;

}

BOOL WTSChannelSetHandleByName(freerdp_peer* client, const char* channel_name,

                               void* handle)

{

	rdpMcsChannel* channel;

	if (!client || !client->context || !client->context->rdp)

		return FALSE;

	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs,

	          channel_name);

	if (!channel)

		return FALSE;

	channel->handle = handle;

	return TRUE;

}

BOOL WTSChannelSetHandleById(freerdp_peer* client, const UINT16 channel_id,

                             void* handle)

{

	rdpMcsChannel* channel;

	if (!client || !client->context || !client->context->rdp)

		return FALSE;

	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);

	if (!channel)

		return FALSE;

	channel->handle = handle;

	return TRUE;

}

void* WTSChannelGetHandleByName(freerdp_peer* client, const char* channel_name)

{

	rdpMcsChannel* channel;

	if (!client || !client->context || !client->context->rdp)

		return NULL;

	channel = wts_get_joined_channel_by_name(client->context->rdp->mcs,

	          channel_name);

	if (!channel)

		return NULL;

	return channel->handle;

}

void* WTSChannelGetHandleById(freerdp_peer* client, const UINT16 channel_id)

{

	rdpMcsChannel* channel;

	if (!client || !client->context || !client->context->rdp)

		return NULL;

	channel = wts_get_joined_channel_by_id(client->context->rdp->mcs, channel_id);

	if (!channel)

		return NULL;

	return channel->handle;

}

BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionW(LPWSTR pTargetServerName,

        ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionA(LPSTR pTargetServerName,

        ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExW(LPWSTR pTargetServerName,

        ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers, DWORD flags)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSStartRemoteControlSessionExA(LPSTR pTargetServerName,

        ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers, DWORD flags)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSStopRemoteControlSession(ULONG LogonId)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId,

                                       PWSTR pPassword, BOOL bWait)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId,

                                       PSTR pPassword, BOOL bWait)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved,

        DWORD Version, PWTS_SERVER_INFOW* ppServerInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved,

        DWORD Version, PWTS_SERVER_INFOA* ppServerInfo, DWORD* pCount)

{

	return FALSE;

}

HANDLE WINAPI FreeRDP_WTSOpenServerW(LPWSTR pServerName)

{

	return INVALID_HANDLE_VALUE;

}

HANDLE WINAPI FreeRDP_WTSOpenServerA(LPSTR pServerName)

{

	rdpContext* context;

	freerdp_peer* client;

	WTSVirtualChannelManager* vcm;

	HANDLE hServer = INVALID_HANDLE_VALUE;

	context = (rdpContext*) pServerName;

	if (!context)

		return INVALID_HANDLE_VALUE;

	client = context->peer;

	if (!client)

	{

		SetLastError(ERROR_INVALID_DATA);

		return INVALID_HANDLE_VALUE;

	}

	vcm = (WTSVirtualChannelManager*) calloc(1, sizeof(WTSVirtualChannelManager));

	if (!vcm)

		goto error_vcm_alloc;

	vcm->client = client;

	vcm->rdp = context->rdp;

	vcm->SessionId = g_SessionId++;

	if (!g_ServerHandles)

	{

		g_ServerHandles = HashTable_New(TRUE);

		if (!g_ServerHandles)

			goto error_free;

	}

	if (HashTable_Add(g_ServerHandles, (void*)(UINT_PTR) vcm->SessionId,

	                  (void*) vcm) < 0)

		goto error_free;

	vcm->queue = MessageQueue_New(NULL);

	if (!vcm->queue)

		goto error_queue;

	vcm->dvc_channel_id_seq = 0;

	vcm->dynamicVirtualChannels = ArrayList_New(TRUE);

	if (!vcm->dynamicVirtualChannels)

		goto error_dynamicVirtualChannels;

	client->ReceiveChannelData = WTSReceiveChannelData;

	hServer = (HANDLE) vcm;

	return hServer;

error_dynamicVirtualChannels:

	MessageQueue_Free(vcm->queue);

error_queue:

	HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR) vcm->SessionId);

error_free:

	free(vcm);

error_vcm_alloc:

	SetLastError(ERROR_NOT_ENOUGH_MEMORY);

	return INVALID_HANDLE_VALUE;

}

HANDLE WINAPI FreeRDP_WTSOpenServerExW(LPWSTR pServerName)

{

	return INVALID_HANDLE_VALUE;

}

HANDLE WINAPI FreeRDP_WTSOpenServerExA(LPSTR pServerName)

{

	return FreeRDP_WTSOpenServerA(pServerName);

}

VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer)

{

	int index;

	int count;

	rdpPeerChannel* channel;

	WTSVirtualChannelManager* vcm;

	vcm = (WTSVirtualChannelManager*) hServer;

	if (vcm)

	{

		HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR) vcm->SessionId);

		ArrayList_Lock(vcm->dynamicVirtualChannels);

		count = ArrayList_Count(vcm->dynamicVirtualChannels);

		for (index = 0; index < count; index++)

		{

			channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels,

			          index);

			WTSVirtualChannelClose(channel);

		}

		ArrayList_Unlock(vcm->dynamicVirtualChannels);

		ArrayList_Free(vcm->dynamicVirtualChannels);

		if (vcm->drdynvc_channel)

		{

			WTSVirtualChannelClose(vcm->drdynvc_channel);

			vcm->drdynvc_channel = NULL;

		}

		MessageQueue_Free(vcm->queue);

		free(vcm);

	}

}

BOOL WINAPI FreeRDP_WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved,

        DWORD Version, PWTS_SESSION_INFOW* ppSessionInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved,

        DWORD Version, PWTS_SESSION_INFOA* ppSessionInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateSessionsExW(HANDLE hServer, DWORD* pLevel,

        DWORD Filter, PWTS_SESSION_INFO_1W* ppSessionInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateSessionsExA(HANDLE hServer, DWORD* pLevel,

        DWORD Filter, PWTS_SESSION_INFO_1A* ppSessionInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved,

        DWORD Version, PWTS_PROCESS_INFOW* ppProcessInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved,

        DWORD Version, PWTS_PROCESS_INFOA* ppProcessInfo, DWORD* pCount)

{

	return FALSE;

}

BOOL WINAPI FreeRDP_WTSTerminateProcess(HANDLE hServer, DWORD ProcessId,

                                        DWORD ExitCode)