22#include <freerdp/config.h>
25#include <winpr/cast.h>
26#include <winpr/stream.h>
27#include <winpr/interlocked.h>
29#include <freerdp/freerdp.h>
30#include <freerdp/channels/drdynvc.h>
31#include <freerdp/utils/drdynvc.h>
33#include "drdynvc_main.h"
35#define TAG CHANNELS_TAG("drdynvc.client")
38static UINT dvcman_channel_close(
DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn);
39static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr);
40static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId,
const BYTE* data,
41 UINT32 dataSize, BOOL* close);
42static UINT drdynvc_send(drdynvcPlugin* drdynvc,
wStream* s);
47 free(listener->channel_name);
56static UINT dvcman_get_configuration(IWTSListener* pListener,
void** ppPropertyBag)
58 WINPR_ASSERT(ppPropertyBag);
59 WINPR_UNUSED(pListener);
60 *ppPropertyBag = NULL;
61 return ERROR_INTERNAL_ERROR;
69static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
70 const char* pszChannelName, ULONG ulFlags,
71 IWTSListenerCallback* pListenerCallback,
72 IWTSListener** ppListener)
78 WLog_DBG(TAG,
"create_listener: %" PRIuz
".%s.", HashTable_Count(dvcman->listeners) + 1,
84 WLog_ERR(TAG,
"calloc failed!");
85 return CHANNEL_RC_NO_MEMORY;
88 listener->iface.GetConfiguration = dvcman_get_configuration;
89 listener->iface.pInterface = NULL;
90 listener->dvcman = dvcman;
91 listener->channel_name = _strdup(pszChannelName);
93 if (!listener->channel_name)
95 WLog_ERR(TAG,
"_strdup failed!");
96 dvcman_wtslistener_free(listener);
97 return CHANNEL_RC_NO_MEMORY;
100 listener->flags = ulFlags;
101 listener->listener_callback = pListenerCallback;
104 *ppListener = (IWTSListener*)listener;
106 if (!HashTable_Insert(dvcman->listeners, listener->channel_name, listener))
108 dvcman_wtslistener_free(listener);
109 return ERROR_INTERNAL_ERROR;
113 return CHANNEL_RC_OK;
116static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)
120 WINPR_UNUSED(pChannelMgr);
124 DVCMAN* dvcman = listener->dvcman;
126 HashTable_Remove(dvcman->listeners, listener->channel_name);
129 return CHANNEL_RC_OK;
137static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints,
const char* name,
140 WINPR_ASSERT(pEntryPoints);
143 WINPR_ASSERT(dvcman);
144 if (!ArrayList_Append(dvcman->plugin_names, name))
145 return ERROR_INTERNAL_ERROR;
146 if (!ArrayList_Append(dvcman->plugins, pPlugin))
147 return ERROR_INTERNAL_ERROR;
149 WLog_DBG(TAG,
"register_plugin: num_plugins %" PRIuz, ArrayList_Count(dvcman->plugins));
150 return CHANNEL_RC_OK;
153static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints,
const char* name)
155 IWTSPlugin* plugin = NULL;
158 WINPR_ASSERT(pEntryPoints);
160 if (!dvcman || !pEntryPoints || !name)
163 nc = ArrayList_Count(dvcman->plugin_names);
164 pc = ArrayList_Count(dvcman->plugins);
168 ArrayList_Lock(dvcman->plugin_names);
169 ArrayList_Lock(dvcman->plugins);
170 for (
size_t i = 0; i < pc; i++)
172 const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);
173 if (strcmp(cur, name) == 0)
175 plugin = ArrayList_GetItem(dvcman->plugins, i);
179 ArrayList_Unlock(dvcman->plugin_names);
180 ArrayList_Unlock(dvcman->plugins);
184static const ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
186 WINPR_ASSERT(pEntryPoints);
190static rdpContext* dvcman_get_rdp_context(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
194 return entry->context;
197static rdpSettings* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
199 rdpContext* context = dvcman_get_rdp_context(pEntryPoints);
200 WINPR_ASSERT(context);
202 return context->settings;
205static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)
209 return dvc->channel_id;
212static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)
216 return dvc->channel_name;
219static DVCMAN_CHANNEL* dvcman_get_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
220 UINT32 ChannelId, BOOL doRef)
225 WINPR_ASSERT(dvcman);
226 HashTable_Lock(dvcman->channelsById);
227 dvcChannel = HashTable_GetItemValue(dvcman->channelsById, &ChannelId);
231 InterlockedIncrement(&dvcChannel->refCounter);
234 HashTable_Unlock(dvcman->channelsById);
238static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
241 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
245 return &channel->iface;
248static void dvcman_plugin_terminate(
void* plugin)
250 IWTSPlugin* pPlugin = plugin;
252 WINPR_ASSERT(pPlugin);
253 UINT error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Terminated, pPlugin);
254 if (error != CHANNEL_RC_OK)
255 WLog_ERR(TAG,
"Terminated failed with error %" PRIu32
"!", error);
258static void wts_listener_free(
void* arg)
261 dvcman_wtslistener_free(listener);
264static BOOL channelIdMatch(
const void* k1,
const void* k2)
268 return *((
const UINT32*)k1) == *((
const UINT32*)k2);
271static UINT32 channelIdHash(
const void*
id)
274 return *((
const UINT32*)
id);
277static void channelByIdCleanerFn(
void* value)
282 dvcman_channel_close(channel, FALSE, TRUE);
283 dvcman_channel_free(channel);
287static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)
295 dvcman->iface.CreateListener = dvcman_create_listener;
296 dvcman->iface.DestroyListener = dvcman_destroy_listener;
297 dvcman->iface.FindChannelById = dvcman_find_channel_by_id;
298 dvcman->iface.GetChannelId = dvcman_get_channel_id;
299 dvcman->iface.GetChannelName = dvcman_get_channel_name;
300 dvcman->drdynvc = plugin;
301 dvcman->channelsById = HashTable_New(TRUE);
303 if (!dvcman->channelsById)
306 HashTable_SetHashFunction(dvcman->channelsById, channelIdHash);
307 obj = HashTable_KeyObject(dvcman->channelsById);
309 obj->fnObjectEquals = channelIdMatch;
311 obj = HashTable_ValueObject(dvcman->channelsById);
313 obj->fnObjectFree = channelByIdCleanerFn;
315 dvcman->pool = StreamPool_New(TRUE, 10);
319 dvcman->listeners = HashTable_New(TRUE);
320 if (!dvcman->listeners)
322 HashTable_SetHashFunction(dvcman->listeners, HashTable_StringHash);
324 obj = HashTable_KeyObject(dvcman->listeners);
325 obj->fnObjectEquals = HashTable_StringCompare;
327 obj = HashTable_ValueObject(dvcman->listeners);
328 obj->fnObjectFree = wts_listener_free;
330 dvcman->plugin_names = ArrayList_New(TRUE);
331 if (!dvcman->plugin_names)
333 obj = ArrayList_Object(dvcman->plugin_names);
334 obj->fnObjectNew = winpr_ObjectStringClone;
335 obj->fnObjectFree = winpr_ObjectStringFree;
337 dvcman->plugins = ArrayList_New(TRUE);
338 if (!dvcman->plugins)
340 obj = ArrayList_Object(dvcman->plugins);
341 obj->fnObjectFree = dvcman_plugin_terminate;
342 return &dvcman->iface;
344 dvcman_free(plugin, &dvcman->iface);
353static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
356 WINPR_ASSERT(drdynvc);
357 WINPR_ASSERT(pChannelMgr);
359 WINPR_ASSERT(context);
361 WLog_Print(drdynvc->log, WLOG_INFO,
"Loading Dynamic Virtual Channel %s", args->argv[0]);
363 PVIRTUALCHANNELENTRY pvce =
364 freerdp_load_channel_addin_entry(args->argv[0], NULL, NULL, FREERDP_ADDIN_CHANNEL_DYNAMIC);
365 PDVC_PLUGIN_ENTRY pDVCPluginEntry = WINPR_FUNC_PTR_CAST(pvce, PDVC_PLUGIN_ENTRY);
371 entryPoints.iface.RegisterPlugin = dvcman_register_plugin;
372 entryPoints.iface.GetPlugin = dvcman_get_plugin;
373 entryPoints.iface.GetPluginData = dvcman_get_plugin_data;
374 entryPoints.iface.GetRdpSettings = dvcman_get_rdp_settings;
375 entryPoints.iface.GetRdpContext = dvcman_get_rdp_context;
376 entryPoints.dvcman = (
DVCMAN*)pChannelMgr;
377 entryPoints.args = args;
378 entryPoints.context = context;
379 return pDVCPluginEntry(&entryPoints.iface);
382 return ERROR_INVALID_FUNCTION;
390 if (channel->dvc_data)
391 Stream_Release(channel->dvc_data);
393 DeleteCriticalSection(&(channel->lock));
394 free(channel->channel_name);
400 WINPR_ASSERT(channel);
401 if (InterlockedDecrement(&channel->refCounter))
404 DVCMAN* dvcman = channel->dvcman;
406 HashTable_Remove(dvcman->channelsById, &channel->channel_id);
411 WINPR_ASSERT(channel);
412 DVCMAN* dvcman = channel->dvcman;
413 drdynvcPlugin* drdynvc = dvcman->drdynvc;
414 wStream* s = StreamPool_Take(dvcman->pool, 5);
418 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
419 return CHANNEL_RC_NO_MEMORY;
422 Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);
423 Stream_Write_UINT32(s, channel->channel_id);
424 return drdynvc_send(drdynvc, s);
429 WINPR_ASSERT(channel);
431 IWTSVirtualChannelCallback* cb = channel->channel_callback;
432 const char* name = channel->channel_name;
433 const UINT32
id = channel->channel_id;
436 if (cb->OnOpen || cb->OnClose)
438 if (!cb->OnOpen || !cb->OnClose)
439 WLog_WARN(TAG,
"{%s:%" PRIu32
"} OnOpen=%p, OnClose=%p", name,
id, cb->OnOpen,
446 WINPR_ASSERT(channel);
449 IWTSVirtualChannelCallback* cb = channel->channel_callback;
452 check_open_close_receive(channel);
453 WINPR_ASSERT(cb->OnDataReceived);
454 return cb->OnDataReceived(cb, data);
457static UINT dvcman_channel_close(
DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn)
459 UINT error = CHANNEL_RC_OK;
460 DrdynvcClientContext* context = NULL;
462 WINPR_ASSERT(channel);
463 switch (channel->state)
465 case DVC_CHANNEL_INIT:
467 case DVC_CHANNEL_RUNNING:
470 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
471 WINPR_ASSERT(drdynvc);
472 context = drdynvc->context;
474 WLog_Print(drdynvc->log, WLOG_DEBUG,
"sending close confirm for '%s'",
475 channel->channel_name);
477 error = dvcchannel_send_close(channel);
478 if (error != CHANNEL_RC_OK)
480 const char* msg =
"error when sending close confirm for '%s'";
482 msg =
"error when sending closeRequest for '%s'";
484 WLog_Print(drdynvc->log, WLOG_DEBUG, msg, channel->channel_name);
488 channel->state = DVC_CHANNEL_CLOSED;
490 IWTSVirtualChannelCallback* cb = channel->channel_callback;
493 check_open_close_receive(channel);
494 IFCALL(cb->OnClose, cb);
497 channel->channel_callback = NULL;
499 if (channel->dvcman && channel->dvcman->drdynvc)
503 IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
504 channel->pInterface);
508 if (!fromHashTableFn)
509 dvcman_channel_unref(channel);
511 case DVC_CHANNEL_CLOSED:
520static DVCMAN_CHANNEL* dvcman_channel_new(WINPR_ATTR_UNUSED drdynvcPlugin* drdynvc,
521 IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
522 const char* ChannelName)
526 WINPR_ASSERT(drdynvc);
527 WINPR_ASSERT(pChannelMgr);
533 channel->dvcman = (
DVCMAN*)pChannelMgr;
534 channel->channel_id = ChannelId;
535 channel->refCounter = 1;
536 channel->state = DVC_CHANNEL_INIT;
537 channel->channel_name = _strdup(ChannelName);
539 if (!channel->channel_name)
542 if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
547 dvcman_channel_free(channel);
551static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
555 WINPR_ASSERT(dvcman);
556 WINPR_UNUSED(drdynvc);
558 HashTable_Clear(dvcman->channelsById);
559 ArrayList_Clear(dvcman->plugins);
560 ArrayList_Clear(dvcman->plugin_names);
561 HashTable_Clear(dvcman->listeners);
563static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
567 WINPR_ASSERT(dvcman);
568 WINPR_UNUSED(drdynvc);
570 HashTable_Free(dvcman->channelsById);
571 ArrayList_Free(dvcman->plugins);
572 ArrayList_Free(dvcman->plugin_names);
573 HashTable_Free(dvcman->listeners);
575 StreamPool_Free(dvcman->pool);
584static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
587 UINT error = CHANNEL_RC_OK;
589 WINPR_ASSERT(dvcman);
590 ArrayList_Lock(dvcman->plugins);
591 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
593 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
595 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
596 if (error != CHANNEL_RC_OK)
598 WLog_Print(drdynvc->log, WLOG_ERROR,
"Initialize failed with error %" PRIu32
"!",
605 ArrayList_Unlock(dvcman->plugins);
614static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize,
const BYTE* pBuffer,
621 WINPR_UNUSED(pReserved);
622 if (!channel || !channel->dvcman)
623 return CHANNEL_RC_BAD_CHANNEL;
625 EnterCriticalSection(&(channel->lock));
627 drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize, &close);
628 LeaveCriticalSection(&(channel->lock));
631 dvcman_channel_close(channel, FALSE, FALSE);
641static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
646 return CHANNEL_RC_BAD_CHANNEL;
648 WLog_DBG(TAG,
"close_channel_iface: id=%" PRIu32
"", channel->channel_id);
649 return dvcman_channel_close(channel, FALSE, FALSE);
657static DVCMAN_CHANNEL* dvcman_create_channel(drdynvcPlugin* drdynvc,
658 IWTSVirtualChannelManager* pChannelMgr,
659 UINT32 ChannelId,
const char* ChannelName, UINT* res)
663 DrdynvcClientContext* context = NULL;
666 IWTSVirtualChannelCallback* pCallback = NULL;
668 WINPR_ASSERT(dvcman);
671 HashTable_Lock(dvcman->listeners);
672 listener = (
DVCMAN_LISTENER*)HashTable_GetItemValue(dvcman->listeners, ChannelName);
675 *res = ERROR_NOT_FOUND;
679 channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
682 switch (channel->state)
684 case DVC_CHANNEL_RUNNING:
685 WLog_Print(drdynvc->log, WLOG_ERROR,
686 "Protocol error: Duplicated ChannelId %" PRIu32
" (%s)!", ChannelId,
688 *res = CHANNEL_RC_ALREADY_OPEN;
691 case DVC_CHANNEL_CLOSED:
692 case DVC_CHANNEL_INIT:
694 WLog_Print(drdynvc->log, WLOG_ERROR,
"not expecting a createChannel from state %d",
696 *res = CHANNEL_RC_INITIALIZATION_ERROR;
702 if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
704 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_channel_new failed!");
705 *res = CHANNEL_RC_NO_MEMORY;
710 if (!HashTable_Insert(dvcman->channelsById, &channel->channel_id, channel))
712 WLog_Print(drdynvc->log, WLOG_ERROR,
"unable to register channel in our channel list");
713 *res = ERROR_INTERNAL_ERROR;
714 dvcman_channel_free(channel);
719 channel->iface.Write = dvcman_write_channel;
720 channel->iface.Close = dvcman_close_channel_iface;
723 *res = listener->listener_callback->OnNewChannelConnection(
724 listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback);
726 if (*res != CHANNEL_RC_OK)
728 WLog_Print(drdynvc->log, WLOG_ERROR,
729 "OnNewChannelConnection failed with error %" PRIu32
"!", *res);
730 *res = ERROR_INTERNAL_ERROR;
731 dvcman_channel_unref(channel);
737 WLog_Print(drdynvc->log, WLOG_ERROR,
"OnNewChannelConnection returned with bAccept FALSE!");
738 *res = ERROR_INTERNAL_ERROR;
739 dvcman_channel_unref(channel);
744 WLog_Print(drdynvc->log, WLOG_DEBUG,
"listener %s created new channel %" PRIu32
"",
745 listener->channel_name, channel->channel_id);
746 channel->state = DVC_CHANNEL_RUNNING;
747 channel->channel_callback = pCallback;
748 channel->pInterface = listener->iface.pInterface;
749 context = dvcman->drdynvc->context;
751 IFCALLRET(context->OnChannelConnected, *res, context, ChannelName, listener->iface.pInterface);
752 if (*res != CHANNEL_RC_OK)
754 WLog_Print(drdynvc->log, WLOG_ERROR,
755 "context.OnChannelConnected failed with error %" PRIu32
"", *res);
759 HashTable_Unlock(dvcman->listeners);
769static UINT dvcman_open_channel(drdynvcPlugin* drdynvc,
DVCMAN_CHANNEL* channel)
771 IWTSVirtualChannelCallback* pCallback = NULL;
772 UINT error = CHANNEL_RC_OK;
774 WINPR_ASSERT(drdynvc);
775 WINPR_ASSERT(channel);
776 if (channel->state == DVC_CHANNEL_RUNNING)
778 pCallback = channel->channel_callback;
780 if (pCallback->OnOpen)
782 check_open_close_receive(channel);
783 error = pCallback->OnOpen(pCallback);
786 WLog_Print(drdynvc->log, WLOG_ERROR,
"OnOpen failed with error %" PRIu32
"!",
792 WLog_Print(drdynvc->log, WLOG_DEBUG,
"open_channel: ChannelId %" PRIu32
"",
793 channel->channel_id);
805static UINT dvcman_receive_channel_data_first(
DVCMAN_CHANNEL* channel, UINT32 length)
807 WINPR_ASSERT(channel);
808 WINPR_ASSERT(channel->dvcman);
809 if (channel->dvc_data)
810 Stream_Release(channel->dvc_data);
812 channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
814 if (!channel->dvc_data)
816 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
817 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
818 return CHANNEL_RC_NO_MEMORY;
821 channel->dvc_data_length = length;
822 return CHANNEL_RC_OK;
831 WINPR_ATTR_UNUSED UINT32 ThreadingFlags)
833 UINT status = CHANNEL_RC_OK;
834 size_t dataSize = Stream_GetRemainingLength(data);
836 WINPR_ASSERT(channel);
837 WINPR_ASSERT(channel->dvcman);
838 if (channel->dvc_data)
840 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
843 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
845 WLog_Print(drdynvc->log, WLOG_ERROR,
"data exceeding declared length!");
846 Stream_Release(channel->dvc_data);
847 channel->dvc_data = NULL;
848 status = ERROR_INVALID_DATA;
852 Stream_Copy(data, channel->dvc_data, dataSize);
854 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
856 Stream_SealLength(channel->dvc_data);
857 Stream_SetPosition(channel->dvc_data, 0);
859 status = dvcman_call_on_receive(channel, channel->dvc_data);
860 Stream_Release(channel->dvc_data);
861 channel->dvc_data = NULL;
865 status = dvcman_call_on_receive(channel, data);
871static UINT8 drdynvc_write_variable_uint(
wStream* s, UINT32 val)
878 Stream_Write_UINT8(s, (UINT8)val);
880 else if (val <= 0xFFFF)
883 Stream_Write_UINT16(s, (UINT16)val);
888 Stream_Write_UINT32(s, val);
899static UINT drdynvc_send(drdynvcPlugin* drdynvc,
wStream* s)
904 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
907 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelWriteEx);
908 status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(
909 drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),
910 (UINT32)Stream_GetPosition(s), s);
916 return CHANNEL_RC_OK;
918 case CHANNEL_RC_NOT_CONNECTED:
920 return CHANNEL_RC_OK;
922 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
924 WLog_ERR(TAG,
"VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
929 WLog_Print(drdynvc->log, WLOG_ERROR,
930 "VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
931 WTSErrorToString(status), status);
941static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId,
const BYTE* data,
942 UINT32 dataSize, BOOL* close)
948 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
952 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
954 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
955 WINPR_ASSERT(dvcman);
957 WLog_Print(drdynvc->log, WLOG_TRACE,
"write_data: ChannelId=%" PRIu32
" size=%" PRIu32
"",
958 ChannelId, dataSize);
959 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
963 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
964 return CHANNEL_RC_NO_MEMORY;
967 Stream_SetPosition(data_out, 1);
968 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
969 pos = Stream_GetPosition(data_out);
975 Stream_Release(data_out);
977 else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
979 Stream_SetPosition(data_out, 0);
980 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
981 Stream_SetPosition(data_out, pos);
982 Stream_Write(data_out, data, dataSize);
983 status = drdynvc_send(drdynvc, data_out);
988 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
989 pos = Stream_GetPosition(data_out);
990 Stream_SetPosition(data_out, 0);
992 const INT32 pdu = (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2);
993 Stream_Write_UINT8(data_out, WINPR_ASSERTING_INT_CAST(UINT8, pdu));
994 Stream_SetPosition(data_out, pos);
997 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
998 const uint32_t chunkLength =
999 CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1000 Stream_Write(data_out, data, chunkLength);
1002 data += chunkLength;
1003 dataSize -= chunkLength;
1005 status = drdynvc_send(drdynvc, data_out);
1007 while (status == CHANNEL_RC_OK && dataSize > 0)
1009 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
1013 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1014 return CHANNEL_RC_NO_MEMORY;
1017 Stream_SetPosition(data_out, 1);
1018 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
1019 pos = Stream_GetPosition(data_out);
1020 Stream_SetPosition(data_out, 0);
1021 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1022 Stream_SetPosition(data_out, pos);
1024 uint32_t chunkLength = dataSize;
1026 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1027 if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)
1028 chunkLength = CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1030 Stream_Write(data_out, data, chunkLength);
1031 data += chunkLength;
1032 dataSize -= chunkLength;
1033 status = drdynvc_send(drdynvc, data_out);
1037 if (status != CHANNEL_RC_OK)
1039 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1040 WTSErrorToString(status), status);
1044 return CHANNEL_RC_OK;
1052static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
1059 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1061 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1062 WINPR_ASSERT(dvcman);
1064 WLog_Print(drdynvc->log, WLOG_TRACE,
"capability_response");
1065 s = StreamPool_Take(dvcman->pool, 4);
1069 WLog_Print(drdynvc->log, WLOG_ERROR,
"Stream_Ndrdynvc_write_variable_uintew failed!");
1070 return CHANNEL_RC_NO_MEMORY;
1073 Stream_Write_UINT16(s, 0x0050);
1074 Stream_Write_UINT16(s, drdynvc->version);
1075 status = drdynvc_send(drdynvc, s);
1077 if (status != CHANNEL_RC_OK)
1079 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1080 WTSErrorToString(status), status);
1091static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
1097 return CHANNEL_RC_BAD_INIT_HANDLE;
1099 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
1100 return ERROR_INVALID_DATA;
1102 WLog_Print(drdynvc->log, WLOG_TRACE,
"capability_request Sp=%d cbChId=%d", Sp, cbChId);
1104 Stream_Read_UINT16(s, drdynvc->version);
1109 if ((drdynvc->version == 2) || (drdynvc->version == 3))
1111 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1112 return ERROR_INVALID_DATA;
1114 Stream_Read_UINT16(s, drdynvc->PriorityCharge0);
1115 Stream_Read_UINT16(s, drdynvc->PriorityCharge1);
1116 Stream_Read_UINT16(s, drdynvc->PriorityCharge2);
1117 Stream_Read_UINT16(s, drdynvc->PriorityCharge3);
1120 status = drdynvc_send_capability_response(drdynvc);
1121 drdynvc->state = DRDYNVC_STATE_READY;
1125static UINT32 drdynvc_cblen_to_bytes(
int cbLen)
1140static UINT32 drdynvc_read_variable_uint(
wStream* s,
int cbLen)
1147 Stream_Read_UINT8(s, val);
1151 Stream_Read_UINT16(s, val);
1155 Stream_Read_UINT32(s, val);
1167static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, UINT8 Sp, UINT8 cbChId,
1172 UINT channel_status = 0;
1175 INT32 retStatus = 0;
1179 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1181 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1182 WINPR_ASSERT(dvcman);
1184 if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1191 drdynvc->version = 3;
1193 if ((status = drdynvc_send_capability_response(drdynvc)))
1195 WLog_Print(drdynvc->log, WLOG_ERROR,
"drdynvc_send_capability_response failed!");
1199 drdynvc->state = DRDYNVC_STATE_READY;
1202 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1203 return ERROR_INVALID_DATA;
1205 const UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1206 const size_t pos = Stream_GetPosition(s);
1207 const char* name = Stream_ConstPointer(s);
1208 const size_t length = Stream_GetRemainingLength(s);
1210 if (strnlen(name, length) >= length)
1211 return ERROR_INVALID_DATA;
1213 WLog_Print(drdynvc->log, WLOG_DEBUG,
1214 "process_create_request: ChannelId=%" PRIu32
" ChannelName=%s", ChannelId, name);
1216 data_out = StreamPool_Take(dvcman->pool, pos + 4);
1219 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1220 return CHANNEL_RC_NO_MEMORY;
1223 Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1224 Stream_SetPosition(s, 1);
1225 Stream_Copy(s, data_out, pos - 1);
1228 dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name, &channel_status);
1229 switch (channel_status)
1232 WLog_Print(drdynvc->log, WLOG_DEBUG,
"channel created");
1235 case CHANNEL_RC_NO_MEMORY:
1236 WLog_Print(drdynvc->log, WLOG_DEBUG,
"not enough memory for channel creation");
1237 retStatus = STATUS_NO_MEMORY;
1239 case ERROR_NOT_FOUND:
1240 WLog_Print(drdynvc->log, WLOG_DEBUG,
"no listener for '%s'", name);
1241 retStatus = STATUS_NOT_FOUND;
1244 WLog_Print(drdynvc->log, WLOG_DEBUG,
"channel creation error");
1245 retStatus = STATUS_UNSUCCESSFUL;
1248 Stream_Write_INT32(data_out, retStatus);
1250 status = drdynvc_send(drdynvc, data_out);
1251 if (status != CHANNEL_RC_OK)
1253 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1254 WTSErrorToString(status), status);
1255 dvcman_channel_unref(channel);
1259 if (channel_status == CHANNEL_RC_OK)
1261 if ((status = dvcman_open_channel(drdynvc, channel)))
1263 WLog_Print(drdynvc->log, WLOG_ERROR,
1264 "dvcman_open_channel failed with error %" PRIu32
"!", status);
1277static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s,
1278 UINT32 ThreadingFlags)
1280 UINT status = CHANNEL_RC_OK;
1282 UINT32 ChannelId = 0;
1285 WINPR_ASSERT(drdynvc);
1286 if (!Stream_CheckAndLogRequiredLength(
1287 TAG, s, drdynvc_cblen_to_bytes(cbChId) + drdynvc_cblen_to_bytes(Sp)))
1288 return ERROR_INVALID_DATA;
1290 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1291 Length = drdynvc_read_variable_uint(s, Sp);
1292 WLog_Print(drdynvc->log, WLOG_TRACE,
1293 "process_data_first: Sp=%d cbChId=%d, ChannelId=%" PRIu32
" Length=%" PRIu32
"", Sp,
1294 cbChId, ChannelId, Length);
1296 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1304 WLog_Print(drdynvc->log, WLOG_ERROR,
"ChannelId %" PRIu32
" not found!", ChannelId);
1305 return CHANNEL_RC_OK;
1308 if (channel->state != DVC_CHANNEL_RUNNING)
1311 status = dvcman_receive_channel_data_first(channel, Length);
1313 if (status == CHANNEL_RC_OK)
1314 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1316 if (status != CHANNEL_RC_OK)
1317 status = dvcman_channel_close(channel, FALSE, FALSE);
1320 dvcman_channel_unref(channel);
1329static UINT drdynvc_process_data(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s,
1330 UINT32 ThreadingFlags)
1332 UINT32 ChannelId = 0;
1334 UINT status = CHANNEL_RC_OK;
1336 WINPR_ASSERT(drdynvc);
1337 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1338 return ERROR_INVALID_DATA;
1340 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1341 WLog_Print(drdynvc->log, WLOG_TRACE,
"process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32
"", Sp,
1344 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1352 WLog_Print(drdynvc->log, WLOG_ERROR,
"ChannelId %" PRIu32
" not found!", ChannelId);
1353 return CHANNEL_RC_OK;
1356 if (channel->state != DVC_CHANNEL_RUNNING)
1359 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1360 if (status != CHANNEL_RC_OK)
1361 status = dvcman_channel_close(channel, FALSE, FALSE);
1364 dvcman_channel_unref(channel);
1373static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s)
1375 UINT32 ChannelId = 0;
1378 WINPR_ASSERT(drdynvc);
1379 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1380 return ERROR_INVALID_DATA;
1382 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1383 WLog_Print(drdynvc->log, WLOG_DEBUG,
1384 "process_close_request: Sp=%d cbChId=%d, ChannelId=%" PRIu32
"", Sp, cbChId,
1387 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1390 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_close_request channel %" PRIu32
" not present",
1392 return CHANNEL_RC_OK;
1395 dvcman_channel_close(channel, TRUE, FALSE);
1396 dvcman_channel_unref(channel);
1397 return CHANNEL_RC_OK;
1405static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc,
wStream* s, UINT32 ThreadingFlags)
1409 WINPR_ASSERT(drdynvc);
1410 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1411 return ERROR_INVALID_DATA;
1413 Stream_Read_UINT8(s, value);
1414 const UINT8 Cmd = (value & 0xf0) >> 4;
1415 const UINT8 Sp = (value & 0x0c) >> 2;
1416 const UINT8 cbChId = (value & 0x03) >> 0;
1417 WLog_Print(drdynvc->log, WLOG_TRACE,
"order_recv: Cmd=%s, Sp=%" PRIu8
" cbChId=%" PRIu8,
1418 drdynvc_get_packet_type(Cmd), Sp, cbChId);
1422 case CAPABILITY_REQUEST_PDU:
1423 return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1425 case CREATE_REQUEST_PDU:
1426 return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1428 case DATA_FIRST_PDU:
1429 return drdynvc_process_data_first(drdynvc, Sp, cbChId, s, ThreadingFlags);
1432 return drdynvc_process_data(drdynvc, Sp, cbChId, s, ThreadingFlags);
1434 case CLOSE_REQUEST_PDU:
1435 return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1438 WLog_Print(drdynvc->log, WLOG_ERROR,
"unknown drdynvc cmd 0x%x", Cmd);
1439 return ERROR_INTERNAL_ERROR;
1448static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc,
void* pData,
1449 UINT32 dataLength, UINT32 totalLength,
1454 WINPR_ASSERT(drdynvc);
1455 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1457 return CHANNEL_RC_OK;
1460 if (dataFlags & CHANNEL_FLAG_FIRST)
1463 if (drdynvc->data_in)
1464 Stream_Release(drdynvc->data_in);
1466 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1469 if (!(data_in = drdynvc->data_in))
1471 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1472 return CHANNEL_RC_NO_MEMORY;
1475 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1477 WLog_Print(drdynvc->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
1478 Stream_Release(drdynvc->data_in);
1479 drdynvc->data_in = NULL;
1480 return ERROR_INTERNAL_ERROR;
1483 Stream_Write(data_in, pData, dataLength);
1485 if (dataFlags & CHANNEL_FLAG_LAST)
1487 const size_t cap = Stream_Capacity(data_in);
1488 const size_t pos = Stream_GetPosition(data_in);
1491 WLog_Print(drdynvc->log, WLOG_ERROR,
"drdynvc_plugin_process_received: read error");
1492 return ERROR_INVALID_DATA;
1495 drdynvc->data_in = NULL;
1496 Stream_SealLength(data_in);
1497 Stream_SetPosition(data_in, 0);
1501 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (
void*)data_in, NULL))
1503 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Post failed!");
1504 return ERROR_INTERNAL_ERROR;
1509 UINT error = drdynvc_order_recv(drdynvc, data_in, TRUE);
1510 Stream_Release(data_in);
1514 WLog_Print(drdynvc->log, WLOG_WARN,
1515 "drdynvc_order_recv failed with error %" PRIu32
"!", error);
1520 return CHANNEL_RC_OK;
1523static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1524 UINT event, LPVOID pData,
1525 UINT32 dataLength, UINT32 totalLength,
1528 UINT error = CHANNEL_RC_OK;
1529 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1531 WINPR_ASSERT(drdynvc);
1534 case CHANNEL_EVENT_DATA_RECEIVED:
1535 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1537 WLog_ERR(TAG,
"drdynvc_virtual_channel_open_event: error no match");
1540 if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1541 totalLength, dataFlags)))
1542 WLog_Print(drdynvc->log, WLOG_ERROR,
1543 "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1549 case CHANNEL_EVENT_WRITE_CANCELLED:
1550 case CHANNEL_EVENT_WRITE_COMPLETE:
1557 case CHANNEL_EVENT_USER:
1563 if (error && drdynvc && drdynvc->rdpcontext)
1564 setChannelError(drdynvc->rdpcontext, error,
1565 "drdynvc_virtual_channel_open_event reported an error");
1568static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1572 wMessage message = { 0 };
1573 UINT error = CHANNEL_RC_OK;
1574 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1578 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1579 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1584 if (!MessageQueue_Wait(drdynvc->queue))
1586 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Wait failed!");
1587 error = ERROR_INTERNAL_ERROR;
1591 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1593 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Peek failed!");
1594 error = ERROR_INTERNAL_ERROR;
1598 if (message.id == WMQ_QUIT)
1601 if (message.id == 0)
1603 UINT32 ThreadingFlags = TRUE;
1604 data = (
wStream*)message.wParam;
1606 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1608 WLog_Print(drdynvc->log, WLOG_WARN,
1609 "drdynvc_order_recv failed with error %" PRIu32
"!", error);
1612 Stream_Release(data);
1622 HashTable_Clear(drdynvcMgr->channelsById);
1625 if (error && drdynvc->rdpcontext)
1626 setChannelError(drdynvc->rdpcontext, error,
1627 "drdynvc_virtual_channel_client_thread reported an error");
1629 ExitThread((DWORD)error);
1633static void drdynvc_queue_object_free(
void* obj)
1636 wMessage* msg = (wMessage*)obj;
1638 if (!msg || (msg->id != 0))
1647static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1651 WINPR_UNUSED(pData);
1652 WINPR_UNUSED(dataLength);
1657 drdynvc->queue = MessageQueue_New(NULL);
1659 if (!drdynvc->queue)
1661 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_New failed!");
1665 obj = MessageQueue_Object(drdynvc->queue);
1666 obj->fnObjectFree = drdynvc_queue_object_free;
1667 drdynvc->channel_mgr = dvcman_new(drdynvc);
1669 if (!drdynvc->channel_mgr)
1671 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_new failed!");
1675 return CHANNEL_RC_OK;
1677 return ERROR_INTERNAL_ERROR;
1685static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1690 rdpSettings* settings = NULL;
1692 WINPR_ASSERT(drdynvc);
1693 WINPR_UNUSED(pData);
1694 WINPR_UNUSED(dataLength);
1697 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1699 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelOpenEx);
1700 status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1701 drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1702 drdynvc_virtual_channel_open_event_ex);
1704 if (status != CHANNEL_RC_OK)
1706 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelOpen failed with %s [%08" PRIX32
"]",
1707 WTSErrorToString(status), status);
1711 WINPR_ASSERT(drdynvc->rdpcontext);
1712 settings = drdynvc->rdpcontext->settings;
1713 WINPR_ASSERT(settings);
1715 for (UINT32 index = 0;
1719 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1720 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1722 if (CHANNEL_RC_OK != error)
1726 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1728 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_init failed with error %" PRIu32
"!", error);
1732 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1736 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1737 (
void*)drdynvc, 0, NULL)))
1739 error = ERROR_INTERNAL_ERROR;
1740 WLog_Print(drdynvc->log, WLOG_ERROR,
"CreateThread failed!");
1744 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1745 WLog_Print(drdynvc->log, WLOG_WARN,
"SetThreadPriority failed, ignoring.");
1757static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1762 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1764 if (drdynvc->OpenHandle == 0)
1765 return CHANNEL_RC_OK;
1769 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1771 status = GetLastError();
1772 WLog_Print(drdynvc->log, WLOG_ERROR,
1773 "MessageQueue_PostQuit failed with error %" PRIu32
"", status);
1778 if (drdynvc->thread)
1780 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1782 status = GetLastError();
1783 WLog_Print(drdynvc->log, WLOG_ERROR,
1784 "WaitForSingleObject failed with error %" PRIu32
"", status);
1788 (void)CloseHandle(drdynvc->thread);
1789 drdynvc->thread = NULL;
1799 HashTable_Clear(drdynvcMgr->channelsById);
1803 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1804 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1805 drdynvc->OpenHandle);
1807 if (status != CHANNEL_RC_OK)
1809 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelClose failed with %s [%08" PRIX32
"]",
1810 WTSErrorToString(status), status);
1813 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1815 MessageQueue_Clear(drdynvc->queue);
1816 drdynvc->OpenHandle = 0;
1818 if (drdynvc->data_in)
1820 Stream_Release(drdynvc->data_in);
1821 drdynvc->data_in = NULL;
1832static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1835 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1837 MessageQueue_Free(drdynvc->queue);
1838 drdynvc->queue = NULL;
1840 if (drdynvc->channel_mgr)
1842 dvcman_free(drdynvc, drdynvc->channel_mgr);
1843 drdynvc->channel_mgr = NULL;
1845 drdynvc->InitHandle = 0;
1846 free(drdynvc->context);
1848 return CHANNEL_RC_OK;
1851static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1853 UINT error = CHANNEL_RC_OK;
1857 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1859 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1862 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1864 ArrayList_Lock(dvcman->plugins);
1865 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1867 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1869 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1870 if (error != CHANNEL_RC_OK)
1872 WLog_Print(drdynvc->log, WLOG_ERROR,
"Attach failed with error %" PRIu32
"!", error);
1878 ArrayList_Unlock(dvcman->plugins);
1882static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1884 UINT error = CHANNEL_RC_OK;
1888 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1890 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1893 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1895 ArrayList_Lock(dvcman->plugins);
1896 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1898 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1900 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1901 if (error != CHANNEL_RC_OK)
1903 WLog_Print(drdynvc->log, WLOG_ERROR,
"Detach failed with error %" PRIu32
"!", error);
1909 ArrayList_Unlock(dvcman->plugins);
1914static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1915 UINT event, LPVOID pData,
1918 UINT error = CHANNEL_RC_OK;
1919 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1921 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
1923 WLog_ERR(TAG,
"drdynvc_virtual_channel_init_event: error no match");
1929 case CHANNEL_EVENT_INITIALIZED:
1930 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
1932 case CHANNEL_EVENT_CONNECTED:
1933 if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
1934 WLog_Print(drdynvc->log, WLOG_ERROR,
1935 "drdynvc_virtual_channel_event_connected failed with error %" PRIu32
"",
1940 case CHANNEL_EVENT_DISCONNECTED:
1941 if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
1942 WLog_Print(drdynvc->log, WLOG_ERROR,
1943 "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
1949 case CHANNEL_EVENT_TERMINATED:
1950 if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
1951 WLog_Print(drdynvc->log, WLOG_ERROR,
1952 "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32
"",
1957 case CHANNEL_EVENT_ATTACHED:
1958 if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
1959 WLog_Print(drdynvc->log, WLOG_ERROR,
1960 "drdynvc_virtual_channel_event_attached failed with error %" PRIu32
"",
1965 case CHANNEL_EVENT_DETACHED:
1966 if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
1967 WLog_Print(drdynvc->log, WLOG_ERROR,
1968 "drdynvc_virtual_channel_event_detached failed with error %" PRIu32
"",
1977 if (error && drdynvc->rdpcontext)
1978 setChannelError(drdynvc->rdpcontext, error,
1979 "drdynvc_virtual_channel_init_event_ex reported an error");
1986static int drdynvc_get_version(DrdynvcClientContext* context)
1988 WINPR_ASSERT(context);
1989 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
1990 WINPR_ASSERT(drdynvc);
1991 return drdynvc->version;
1995#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
1997FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2001 drdynvcPlugin* drdynvc = NULL;
2002 DrdynvcClientContext* context = NULL;
2004 drdynvc = (drdynvcPlugin*)calloc(1,
sizeof(drdynvcPlugin));
2006 WINPR_ASSERT(pEntryPoints);
2009 WLog_ERR(TAG,
"calloc failed!");
2013 drdynvc->channelDef.options =
2014 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2015 (void)sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name),
2016 DRDYNVC_SVC_CHANNEL_NAME);
2017 drdynvc->state = DRDYNVC_STATE_INITIAL;
2021 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2023 context = (DrdynvcClientContext*)calloc(1,
sizeof(DrdynvcClientContext));
2027 WLog_Print(drdynvc->log, WLOG_ERROR,
"calloc failed!");
2032 context->handle = (
void*)drdynvc;
2033 context->custom = NULL;
2034 drdynvc->context = context;
2035 context->GetVersion = drdynvc_get_version;
2036 drdynvc->rdpcontext = pEntryPointsEx->context;
2038 FreeRDP_TransportDumpReplay) &&
2040 FreeRDP_SynchronousDynamicChannels))
2041 drdynvc->async = TRUE;
2044 drdynvc->log = WLog_Get(TAG);
2045 WLog_Print(drdynvc->log, WLOG_DEBUG,
"VirtualChannelEntryEx");
2046 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2048 drdynvc->InitHandle = pInitHandle;
2050 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelInitEx);
2051 rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
2052 drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2053 drdynvc_virtual_channel_init_event_ex);
2055 if (CHANNEL_RC_OK != rc)
2057 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelInit failed with %s [%08" PRIX32
"]",
2058 WTSErrorToString(rc), rc);
2059 free(drdynvc->context);
2064 drdynvc->channelEntryPoints.pInterface = context;
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
This struct contains function pointer to initialize/free objects.