/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Dynamic Virtual Channel

 *

 * Copyright 2010-2011 Vic Lee

 * 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 <winpr/crt.h>

#include <winpr/stream.h>

#include "drdynvc_main.h"

#define TAG CHANNELS_TAG("drdynvc.client")

static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr);

static void dvcman_channel_free(void* channel);

static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,

                               UINT32 dataSize);

static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s);

static void dvcman_wtslistener_free(DVCMAN_LISTENER* listener)

{

	if (listener)

		free(listener->channel_name);

	free(listener);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_get_configuration(IWTSListener* pListener, void** ppPropertyBag)

{

	WINPR_UNUSED(pListener);

	*ppPropertyBag = NULL;

	return ERROR_INTERNAL_ERROR;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,

                                   const char* pszChannelName, ULONG ulFlags,

                                   IWTSListenerCallback* pListenerCallback,

                                   IWTSListener** ppListener)

{

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	DVCMAN_LISTENER* listener;

	WLog_DBG(TAG, "create_listener: %d.%s.", ArrayList_Count(dvcman->listeners) + 1,

	         pszChannelName);

	listener = (DVCMAN_LISTENER*)calloc(1, sizeof(DVCMAN_LISTENER));

	if (!listener)

	{

		WLog_ERR(TAG, "calloc failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	listener->iface.GetConfiguration = dvcman_get_configuration;

	listener->iface.pInterface = NULL;

	listener->dvcman = dvcman;

	listener->channel_name = _strdup(pszChannelName);

	if (!listener->channel_name)

	{

		WLog_ERR(TAG, "_strdup failed!");

		dvcman_wtslistener_free(listener);

		return CHANNEL_RC_NO_MEMORY;

	}

	listener->flags = ulFlags;

	listener->listener_callback = pListenerCallback;

	if (ppListener)

		*ppListener = (IWTSListener*)listener;

	if (ArrayList_Add(dvcman->listeners, listener) < 0)

		return ERROR_INTERNAL_ERROR;

	return CHANNEL_RC_OK;

}

static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)

{

	DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)pListener;

	WINPR_UNUSED(pChannelMgr);

	if (listener)

	{

		DVCMAN* dvcman = listener->dvcman;

		if (dvcman)

			ArrayList_Remove(dvcman->listeners, listener);

	}

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name,

                                   IWTSPlugin* pPlugin)

{

	DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;

	if (ArrayList_Add(dvcman->plugin_names, _strdup(name)) < 0)

		return ERROR_INTERNAL_ERROR;

	if (ArrayList_Add(dvcman->plugins, pPlugin) < 0)

		return ERROR_INTERNAL_ERROR;

	WLog_DBG(TAG, "register_plugin: num_plugins %d", ArrayList_Count(dvcman->plugins));

	return CHANNEL_RC_OK;

}

static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name)

{

	IWTSPlugin* plugin = NULL;

	size_t i, nc, pc;

	DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;

	if (!dvcman || !pEntryPoints || !name)

		return NULL;

	nc = ArrayList_Count(dvcman->plugin_names);

	pc = ArrayList_Count(dvcman->plugins);

	if (nc != pc)

		return NULL;

	ArrayList_Lock(dvcman->plugin_names);

	ArrayList_Lock(dvcman->plugins);

	for (i = 0; i < pc; i++)

	{

		const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);

		if (strcmp(cur, name) == 0)

		{

			plugin = ArrayList_GetItem(dvcman->plugins, i);

			break;

		}

	}

	ArrayList_Unlock(dvcman->plugin_names);

	ArrayList_Unlock(dvcman->plugins);

	return plugin;

}

static ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)

{

	return ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->args;

}

static void* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)

{

	return (void*)((DVCMAN_ENTRY_POINTS*)pEntryPoints)->settings;

}

static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)

{

	DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;

	return dvc->channel_id;

}

static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)

{

	DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;

	return dvc->channel_name;

}

static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,

                                                     UINT32 ChannelId)

{

	int index;

	IWTSVirtualChannel* channel = NULL;

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	ArrayList_Lock(dvcman->channels);

	for (index = 0; index < ArrayList_Count(dvcman->channels); index++)

	{

		DVCMAN_CHANNEL* cur = (DVCMAN_CHANNEL*)ArrayList_GetItem(dvcman->channels, index);

		if (cur->channel_id == ChannelId)

		{

			channel = &cur->iface;

			break;

		}

	}

	ArrayList_Unlock(dvcman->channels);

	return channel;

}

static void dvcman_plugin_terminate(void* plugin)

{

	IWTSPlugin* pPlugin = plugin;

	UINT error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Terminated, pPlugin);

	if (error != CHANNEL_RC_OK)

		WLog_ERR(TAG, "Terminated failed with error %" PRIu32 "!", error);

}

static void wts_listener_free(void* arg)

{

	DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)arg;

	dvcman_wtslistener_free(listener);

}

static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)

{

	wObject* obj;

	DVCMAN* dvcman;

	dvcman = (DVCMAN*)calloc(1, sizeof(DVCMAN));

	if (!dvcman)

		return NULL;

	dvcman->iface.CreateListener = dvcman_create_listener;

	dvcman->iface.DestroyListener = dvcman_destroy_listener;

	dvcman->iface.FindChannelById = dvcman_find_channel_by_id;

	dvcman->iface.GetChannelId = dvcman_get_channel_id;

	dvcman->iface.GetChannelName = dvcman_get_channel_name;

	dvcman->drdynvc = plugin;

	dvcman->channels = ArrayList_New(TRUE);

	if (!dvcman->channels)

		goto fail;

	obj = ArrayList_Object(dvcman->channels);

	obj->fnObjectFree = dvcman_channel_free;

	dvcman->pool = StreamPool_New(TRUE, 10);

	if (!dvcman->pool)

		goto fail;

	dvcman->listeners = ArrayList_New(TRUE);

	if (!dvcman->listeners)

		goto fail;

	obj = ArrayList_Object(dvcman->listeners);

	obj->fnObjectFree = wts_listener_free;

	dvcman->plugin_names = ArrayList_New(TRUE);

	if (!dvcman->plugin_names)

		goto fail;

	obj = ArrayList_Object(dvcman->plugin_names);

	obj->fnObjectFree = free;

	dvcman->plugins = ArrayList_New(TRUE);

	if (!dvcman->plugins)

		goto fail;

	obj = ArrayList_Object(dvcman->plugins);

	obj->fnObjectFree = dvcman_plugin_terminate;

	return &dvcman->iface;

fail:

	dvcman_free(plugin, &dvcman->iface);

	return NULL;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,

                              ADDIN_ARGV* args, rdpSettings* settings)

{

	DVCMAN_ENTRY_POINTS entryPoints;

	PDVC_PLUGIN_ENTRY pDVCPluginEntry = NULL;

	WLog_Print(drdynvc->log, WLOG_INFO, "Loading Dynamic Virtual Channel %s", args->argv[0]);

	pDVCPluginEntry = (PDVC_PLUGIN_ENTRY)freerdp_load_channel_addin_entry(

	    args->argv[0], NULL, NULL, FREERDP_ADDIN_CHANNEL_DYNAMIC);

	if (pDVCPluginEntry)

	{

		entryPoints.iface.RegisterPlugin = dvcman_register_plugin;

		entryPoints.iface.GetPlugin = dvcman_get_plugin;

		entryPoints.iface.GetPluginData = dvcman_get_plugin_data;

		entryPoints.iface.GetRdpSettings = dvcman_get_rdp_settings;

		entryPoints.dvcman = (DVCMAN*)pChannelMgr;

		entryPoints.args = args;

		entryPoints.settings = settings;

		return pDVCPluginEntry(&entryPoints.iface);

	}

	return ERROR_INVALID_FUNCTION;

}

static DVCMAN_CHANNEL* dvcman_channel_new(drdynvcPlugin* drdynvc,

                                          IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,

                                          const char* ChannelName)

{

	DVCMAN_CHANNEL* channel;

	if (dvcman_find_channel_by_id(pChannelMgr, ChannelId))

	{

		WLog_Print(drdynvc->log, WLOG_ERROR,

		           "Protocol error: Duplicated ChannelId %" PRIu32 " (%s)!", ChannelId,

		           ChannelName);

		return NULL;

	}

	channel = (DVCMAN_CHANNEL*)calloc(1, sizeof(DVCMAN_CHANNEL));

	if (!channel)

		goto fail;

	channel->dvcman = (DVCMAN*)pChannelMgr;

	channel->channel_id = ChannelId;

	channel->channel_name = _strdup(ChannelName);

	if (!channel->channel_name)

		goto fail;

	if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))

		goto fail;

	return channel;

fail:

	dvcman_channel_free(channel);

	return NULL;

}

static void dvcman_channel_free(void* arg)

{

	DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)arg;

	UINT error = CHANNEL_RC_OK;

	if (channel)

	{

		if (channel->channel_callback)

		{

			IFCALL(channel->channel_callback->OnClose, channel->channel_callback);

			channel->channel_callback = NULL;

		}

		if (channel->status == CHANNEL_RC_OK)

		{

			IWTSVirtualChannel* ichannel = (IWTSVirtualChannel*)channel;

			if (channel->dvcman && channel->dvcman->drdynvc)

			{

				DrdynvcClientContext* context = channel->dvcman->drdynvc->context;

				if (context)

				{

					IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,

					          channel->pInterface);

				}

			}

			error = IFCALLRESULT(CHANNEL_RC_OK, ichannel->Close, ichannel);

			if (error != CHANNEL_RC_OK)

				WLog_ERR(TAG, "Close failed with error %" PRIu32 "!", error);

		}

		if (channel->dvc_data)

			Stream_Release(channel->dvc_data);

		DeleteCriticalSection(&(channel->lock));

		free(channel->channel_name);

	}

	free(channel);

}

static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)

{

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	WINPR_UNUSED(drdynvc);

	ArrayList_Clear(dvcman->plugins);

	ArrayList_Clear(dvcman->channels);

	ArrayList_Clear(dvcman->plugin_names);

	ArrayList_Clear(dvcman->listeners);

}

static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)

{

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	WINPR_UNUSED(drdynvc);

	ArrayList_Free(dvcman->plugins);

	ArrayList_Free(dvcman->channels);

	ArrayList_Free(dvcman->plugin_names);

	ArrayList_Free(dvcman->listeners);

	StreamPool_Free(dvcman->pool);

	free(dvcman);

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)

{

	size_t i;

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	UINT error = CHANNEL_RC_OK;

	ArrayList_Lock(dvcman->plugins);

	for (i = 0; i < ArrayList_Count(dvcman->plugins); i++)

	{

		IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);

		error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);

		if (error != CHANNEL_RC_OK)

		{

			WLog_Print(drdynvc->log, WLOG_ERROR, "Initialize failed with error %" PRIu32 "!",

			           error);

			goto fail;

		}

	}

fail:

	ArrayList_Unlock(dvcman->plugins);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize, const BYTE* pBuffer,

                                 void* pReserved)

{

	UINT status;

	DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;

	WINPR_UNUSED(pReserved);

	if (!channel || !channel->dvcman)

		return CHANNEL_RC_BAD_CHANNEL;

	EnterCriticalSection(&(channel->lock));

	status = drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize);

	LeaveCriticalSection(&(channel->lock));

	return status;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)

{

	DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;

	if (!channel)

		return CHANNEL_RC_BAD_CHANNEL;

	WLog_DBG(TAG, "close_channel_iface: id=%" PRIu32 "", channel->channel_id);

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_create_channel(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,

                                  UINT32 ChannelId, const char* ChannelName)

{

	size_t i;

	BOOL bAccept;

	DVCMAN_CHANNEL* channel;

	DrdynvcClientContext* context;

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	UINT error;

	if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))

	{

		WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_channel_new failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	channel->status = ERROR_NOT_CONNECTED;

	if (ArrayList_Add(dvcman->channels, channel) < 0)

		return ERROR_INTERNAL_ERROR;

	ArrayList_Lock(dvcman->listeners);

	for (i = 0; i < ArrayList_Count(dvcman->listeners); i++)

	{

		DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)ArrayList_GetItem(dvcman->listeners, i);

		if (strcmp(listener->channel_name, ChannelName) == 0)

		{

			IWTSVirtualChannelCallback* pCallback = NULL;

			channel->iface.Write = dvcman_write_channel;

			channel->iface.Close = dvcman_close_channel_iface;

			bAccept = TRUE;

			if ((error = listener->listener_callback->OnNewChannelConnection(

			         listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback)) ==

			        CHANNEL_RC_OK &&

			    bAccept)

			{

				WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s created new channel %" PRIu32 "",

				           listener->channel_name, channel->channel_id);

				channel->status = CHANNEL_RC_OK;

				channel->channel_callback = pCallback;

				channel->pInterface = listener->iface.pInterface;

				context = dvcman->drdynvc->context;

				IFCALLRET(context->OnChannelConnected, error, context, ChannelName,

				          listener->iface.pInterface);

				if (error)

					WLog_Print(drdynvc->log, WLOG_ERROR,

					           "context.OnChannelConnected failed with error %" PRIu32 "", error);

				goto fail;

			}

			else

			{

				if (error)

				{

					WLog_Print(drdynvc->log, WLOG_ERROR,

					           "OnNewChannelConnection failed with error %" PRIu32 "!", error);

					goto fail;

				}

				else

				{

					WLog_Print(drdynvc->log, WLOG_ERROR,

					           "OnNewChannelConnection returned with bAccept FALSE!");

					error = ERROR_INTERNAL_ERROR;

					goto fail;

				}

			}

		}

	}

	error = ERROR_INTERNAL_ERROR;

fail:

	ArrayList_Unlock(dvcman->listeners);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_open_channel(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,

                                UINT32 ChannelId)

{

	DVCMAN_CHANNEL* channel;

	IWTSVirtualChannelCallback* pCallback;

	UINT error;

	channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);

	if (!channel)

	{

		WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);

		return ERROR_INTERNAL_ERROR;

	}

	if (channel->status == CHANNEL_RC_OK)

	{

		pCallback = channel->channel_callback;

		if ((pCallback->OnOpen) && (error = pCallback->OnOpen(pCallback)))

		{

			WLog_Print(drdynvc->log, WLOG_ERROR, "OnOpen failed with error %" PRIu32 "!", error);

			return error;

		}

		WLog_Print(drdynvc->log, WLOG_DEBUG, "open_channel: ChannelId %" PRIu32 "", ChannelId);

	}

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_close_channel(IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,

                                 BOOL bSendClosePDU)

{

	DVCMAN_CHANNEL* channel;

	UINT error = CHANNEL_RC_OK;

	DVCMAN* dvcman = (DVCMAN*)pChannelMgr;

	drdynvcPlugin* drdynvc = dvcman->drdynvc;

	channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);

	if (!channel)

	{

		// WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %"PRIu32" not found!", ChannelId);

		/**

		 * Windows 8 / Windows Server 2012 send close requests for channels that failed to be

		 * created. Do not warn, simply return success here.

		 */

		return CHANNEL_RC_OK;

	}

	if (drdynvc && bSendClosePDU)

	{

		wStream* s = StreamPool_Take(dvcman->pool, 5);

		if (!s)

		{

			WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");

			error = CHANNEL_RC_NO_MEMORY;

		}

		else

		{

			Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);

			Stream_Write_UINT32(s, ChannelId);

			error = drdynvc_send(drdynvc, s);

		}

	}

	ArrayList_Remove(dvcman->channels, channel);

	return error;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_receive_channel_data_first(drdynvcPlugin* drdynvc,

                                              IWTSVirtualChannelManager* pChannelMgr,

                                              UINT32 ChannelId, UINT32 length)

{

	DVCMAN_CHANNEL* channel;

	channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);

	if (!channel)

	{

		/**

		 * Windows Server 2012 R2 can send some messages over

		 * Microsoft::Windows::RDS::Geometry::v08.01 even if the dynamic virtual channel wasn't

		 * registered on our side. Ignoring it works.

		 */

		WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);

		return CHANNEL_RC_OK;

	}

	if (channel->dvc_data)

		Stream_Release(channel->dvc_data);

	channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);

	if (!channel->dvc_data)

	{

		WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	channel->dvc_data_length = length;

	return CHANNEL_RC_OK;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT dvcman_receive_channel_data(drdynvcPlugin* drdynvc,

                                        IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,

                                        wStream* data)

{

	UINT status = CHANNEL_RC_OK;

	DVCMAN_CHANNEL* channel;

	size_t dataSize = Stream_GetRemainingLength(data);

	channel = (DVCMAN_CHANNEL*)dvcman_find_channel_by_id(pChannelMgr, ChannelId);

	if (!channel)

	{

		/* Windows 8.1 tries to open channels not created.

		 * Ignore cases like this. */

		WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);

		return CHANNEL_RC_OK;

	}

	if (channel->dvc_data)

	{

		/* Fragmented data */

		if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)

		{

			WLog_Print(drdynvc->log, WLOG_ERROR, "data exceeding declared length!");

			Stream_Release(channel->dvc_data);

			channel->dvc_data = NULL;

			return ERROR_INVALID_DATA;

		}

		Stream_Copy(data, channel->dvc_data, dataSize);

		if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)

		{

			Stream_SealLength(channel->dvc_data);

			Stream_SetPosition(channel->dvc_data, 0);

			status = channel->channel_callback->OnDataReceived(channel->channel_callback,

			                                                   channel->dvc_data);

			Stream_Release(channel->dvc_data);

			channel->dvc_data = NULL;

		}

	}

	else

	{

		status = channel->channel_callback->OnDataReceived(channel->channel_callback, data);

	}

	return status;

}

static UINT8 drdynvc_write_variable_uint(wStream* s, UINT32 val)

{

	UINT8 cb;

	if (val <= 0xFF)

	{

		cb = 0;

		Stream_Write_UINT8(s, (UINT8)val);

	}

	else if (val <= 0xFFFF)

	{

		cb = 1;

		Stream_Write_UINT16(s, (UINT16)val);

	}

	else

	{

		cb = 2;

		Stream_Write_UINT32(s, val);

	}

	return cb;

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s)

{

	UINT status;

	if (!drdynvc)

		status = CHANNEL_RC_BAD_CHANNEL_HANDLE;

	else

	{

		status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(

		    drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),

		    (UINT32)Stream_GetPosition(s), s);

	}

	switch (status)

	{

		case CHANNEL_RC_OK:

			return CHANNEL_RC_OK;

		case CHANNEL_RC_NOT_CONNECTED:

			Stream_Release(s);

			return CHANNEL_RC_OK;

		case CHANNEL_RC_BAD_CHANNEL_HANDLE:

			Stream_Release(s);

			WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");

			return status;

		default:

			Stream_Release(s);

			WLog_Print(drdynvc->log, WLOG_ERROR,

			           "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",

			           WTSErrorToString(status), status);

			return status;

	}

}

/**

 * Function description

 *

 * @return 0 on success, otherwise a Win32 error code

 */

static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,

                               UINT32 dataSize)

{

	wStream* data_out;

	size_t pos;

	UINT8 cbChId;

	UINT8 cbLen;

	unsigned long chunkLength;

	UINT status = CHANNEL_RC_BAD_INIT_HANDLE;

	DVCMAN* dvcman;

	if (!drdynvc)

		return CHANNEL_RC_BAD_CHANNEL_HANDLE;

	dvcman = (DVCMAN*)drdynvc->channel_mgr;

	WLog_Print(drdynvc->log, WLOG_DEBUG, "write_data: ChannelId=%" PRIu32 " size=%" PRIu32 "",

	           ChannelId, dataSize);

	data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);

	if (!data_out)

	{

		WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");

		return CHANNEL_RC_NO_MEMORY;

	}

	Stream_SetPosition(data_out, 1);

	cbChId = drdynvc_write_variable_uint(data_out, ChannelId);

	pos = Stream_GetPosition(data_out);

	if (dataSize == 0)

	{

		dvcman_close_channel(drdynvc->channel_mgr, ChannelId, TRUE);

		Stream_Release(data_out);

	}

	else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)

	{

		Stream_SetPosition(data_out, 0);

		Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);

		Stream_SetPosition(data_out, pos);

		Stream_Write(data_out, data, dataSize);

		status = drdynvc_send(drdynvc, data_out);

	}

	else

	{

		/* Fragment the data */

		cbLen = drdynvc_write_variable_uint(data_out, dataSize);

		pos = Stream_GetPosition(data_out);

		Stream_SetPosition(data_out, 0);

		Stream_Write_UINT8(data_out, (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2));

		Stream_SetPosition(data_out, pos);

		chunkLength = CHANNEL_CHUNK_LENGTH - pos;

		Stream_Write(data_out, data, chunkLength);

		data += chunkLength;

		dataSize -= chunkLength;

		status = drdynvc_send(drdynvc, data_out);

		while (status == CHANNEL_RC_OK && dataSize > 0)

		{

			data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);

			if (!data_out)

			{

				WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");

				return CHANNEL_RC_NO_MEMORY;

			}

			Stream_SetPosition(data_out, 1);

			cbChId = drdynvc_write_variable_uint(data_out, ChannelId);

			pos = Stream_GetPosition(data_out);

			Stream_SetPosition(data_out, 0);

			Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);

			Stream_SetPosition(data_out, pos);

			chunkLength = dataSize;

			if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)

				chunkLength = CHANNEL_CHUNK_LENGTH - pos;

			Stream_Write(data_out, data, chunkLength);

			data += chunkLength;

			dataSize -= chunkLength;