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")
37static const char* channel_state2str(DVC_CHANNEL_STATE state)
41 case DVC_CHANNEL_INIT:
42 return "DVC_CHANNEL_INIT";
43 case DVC_CHANNEL_RUNNING:
44 return "DVC_CHANNEL_RUNNING";
45 case DVC_CHANNEL_CLOSED:
46 return "DVC_CHANNEL_CLOSED";
48 return "DVC_CHANNEL_UNKNOWN";
53static UINT dvcman_channel_close(
DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn);
54static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr);
55static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId,
const BYTE* data,
56 UINT32 dataSize, BOOL* close);
57static UINT drdynvc_send(drdynvcPlugin* drdynvc,
wStream* s);
62 free(listener->channel_name);
71static UINT dvcman_get_configuration(IWTSListener* pListener,
void** ppPropertyBag)
73 WINPR_ASSERT(ppPropertyBag);
74 WINPR_UNUSED(pListener);
75 *ppPropertyBag = NULL;
76 return ERROR_INTERNAL_ERROR;
84static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
85 const char* pszChannelName, ULONG ulFlags,
86 IWTSListenerCallback* pListenerCallback,
87 IWTSListener** ppListener)
93 WLog_DBG(TAG,
"create_listener: %" PRIuz
".%s.", HashTable_Count(dvcman->listeners) + 1,
99 WLog_ERR(TAG,
"calloc failed!");
100 return CHANNEL_RC_NO_MEMORY;
103 listener->iface.GetConfiguration = dvcman_get_configuration;
104 listener->iface.pInterface = NULL;
105 listener->dvcman = dvcman;
106 listener->channel_name = _strdup(pszChannelName);
108 if (!listener->channel_name)
110 WLog_ERR(TAG,
"_strdup failed!");
111 dvcman_wtslistener_free(listener);
112 return CHANNEL_RC_NO_MEMORY;
115 listener->flags = ulFlags;
116 listener->listener_callback = pListenerCallback;
119 *ppListener = (IWTSListener*)listener;
121 if (!HashTable_Insert(dvcman->listeners, listener->channel_name, listener))
123 dvcman_wtslistener_free(listener);
124 return ERROR_INTERNAL_ERROR;
128 return CHANNEL_RC_OK;
131static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)
135 WINPR_UNUSED(pChannelMgr);
139 DVCMAN* dvcman = listener->dvcman;
141 HashTable_Remove(dvcman->listeners, listener->channel_name);
144 return CHANNEL_RC_OK;
152static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints,
const char* name,
155 WINPR_ASSERT(pEntryPoints);
158 WINPR_ASSERT(dvcman);
159 if (!ArrayList_Append(dvcman->plugin_names, name))
160 return ERROR_INTERNAL_ERROR;
161 if (!ArrayList_Append(dvcman->plugins, pPlugin))
162 return ERROR_INTERNAL_ERROR;
164 WLog_DBG(TAG,
"register_plugin: num_plugins %" PRIuz, ArrayList_Count(dvcman->plugins));
165 return CHANNEL_RC_OK;
168static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints,
const char* name)
170 IWTSPlugin* plugin = NULL;
173 WINPR_ASSERT(pEntryPoints);
175 if (!dvcman || !pEntryPoints || !name)
178 nc = ArrayList_Count(dvcman->plugin_names);
179 pc = ArrayList_Count(dvcman->plugins);
183 ArrayList_Lock(dvcman->plugin_names);
184 ArrayList_Lock(dvcman->plugins);
185 for (
size_t i = 0; i < pc; i++)
187 const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);
188 if (strcmp(cur, name) == 0)
190 plugin = ArrayList_GetItem(dvcman->plugins, i);
194 ArrayList_Unlock(dvcman->plugin_names);
195 ArrayList_Unlock(dvcman->plugins);
199static const ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
201 WINPR_ASSERT(pEntryPoints);
205static rdpContext* dvcman_get_rdp_context(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
209 return entry->context;
212static rdpSettings* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
214 rdpContext* context = dvcman_get_rdp_context(pEntryPoints);
215 WINPR_ASSERT(context);
217 return context->settings;
220static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)
224 return dvc->channel_id;
227static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)
231 return dvc->channel_name;
234static DVCMAN_CHANNEL* dvcman_get_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
235 UINT32 ChannelId, BOOL doRef)
240 WINPR_ASSERT(dvcman);
241 HashTable_Lock(dvcman->channelsById);
242 dvcChannel = HashTable_GetItemValue(dvcman->channelsById, &ChannelId);
246 InterlockedIncrement(&dvcChannel->refCounter);
249 HashTable_Unlock(dvcman->channelsById);
253static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
256 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
260 return &channel->iface;
263static void dvcman_plugin_terminate(
void* plugin)
265 IWTSPlugin* pPlugin = plugin;
267 WINPR_ASSERT(pPlugin);
268 UINT error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Terminated, pPlugin);
269 if (error != CHANNEL_RC_OK)
270 WLog_ERR(TAG,
"Terminated failed with error %" PRIu32
"!", error);
273static void wts_listener_free(
void* arg)
276 dvcman_wtslistener_free(listener);
279static BOOL channelIdMatch(
const void* k1,
const void* k2)
283 return *((
const UINT32*)k1) == *((
const UINT32*)k2);
286static UINT32 channelIdHash(
const void*
id)
289 return *((
const UINT32*)
id);
292static void channelByIdCleanerFn(
void* value)
297 dvcman_channel_close(channel, FALSE, TRUE);
298 dvcman_channel_free(channel);
302static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)
310 dvcman->iface.CreateListener = dvcman_create_listener;
311 dvcman->iface.DestroyListener = dvcman_destroy_listener;
312 dvcman->iface.FindChannelById = dvcman_find_channel_by_id;
313 dvcman->iface.GetChannelId = dvcman_get_channel_id;
314 dvcman->iface.GetChannelName = dvcman_get_channel_name;
315 dvcman->drdynvc = plugin;
316 dvcman->channelsById = HashTable_New(TRUE);
318 if (!dvcman->channelsById)
321 HashTable_SetHashFunction(dvcman->channelsById, channelIdHash);
322 obj = HashTable_KeyObject(dvcman->channelsById);
324 obj->fnObjectEquals = channelIdMatch;
326 obj = HashTable_ValueObject(dvcman->channelsById);
328 obj->fnObjectFree = channelByIdCleanerFn;
330 dvcman->pool = StreamPool_New(TRUE, 10);
334 dvcman->listeners = HashTable_New(TRUE);
335 if (!dvcman->listeners)
337 HashTable_SetHashFunction(dvcman->listeners, HashTable_StringHash);
339 obj = HashTable_KeyObject(dvcman->listeners);
340 obj->fnObjectEquals = HashTable_StringCompare;
342 obj = HashTable_ValueObject(dvcman->listeners);
343 obj->fnObjectFree = wts_listener_free;
345 dvcman->plugin_names = ArrayList_New(TRUE);
346 if (!dvcman->plugin_names)
348 obj = ArrayList_Object(dvcman->plugin_names);
349 obj->fnObjectNew = winpr_ObjectStringClone;
350 obj->fnObjectFree = winpr_ObjectStringFree;
352 dvcman->plugins = ArrayList_New(TRUE);
353 if (!dvcman->plugins)
355 obj = ArrayList_Object(dvcman->plugins);
356 obj->fnObjectFree = dvcman_plugin_terminate;
357 return &dvcman->iface;
359 dvcman_free(plugin, &dvcman->iface);
368static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
371 WINPR_ASSERT(drdynvc);
372 WINPR_ASSERT(pChannelMgr);
374 WINPR_ASSERT(context);
376 WLog_Print(drdynvc->log, WLOG_INFO,
"Loading Dynamic Virtual Channel %s", args->argv[0]);
378 PVIRTUALCHANNELENTRY pvce =
379 freerdp_load_channel_addin_entry(args->argv[0], NULL, NULL, FREERDP_ADDIN_CHANNEL_DYNAMIC);
380 PDVC_PLUGIN_ENTRY pDVCPluginEntry = WINPR_FUNC_PTR_CAST(pvce, PDVC_PLUGIN_ENTRY);
386 entryPoints.iface.RegisterPlugin = dvcman_register_plugin;
387 entryPoints.iface.GetPlugin = dvcman_get_plugin;
388 entryPoints.iface.GetPluginData = dvcman_get_plugin_data;
389 entryPoints.iface.GetRdpSettings = dvcman_get_rdp_settings;
390 entryPoints.iface.GetRdpContext = dvcman_get_rdp_context;
391 entryPoints.dvcman = (
DVCMAN*)pChannelMgr;
392 entryPoints.args = args;
393 entryPoints.context = context;
394 return pDVCPluginEntry(&entryPoints.iface);
397 return ERROR_INVALID_FUNCTION;
405 if (channel->dvc_data)
406 Stream_Release(channel->dvc_data);
408 DeleteCriticalSection(&(channel->lock));
409 free(channel->channel_name);
415 WINPR_ASSERT(channel);
416 if (InterlockedDecrement(&channel->refCounter))
419 DVCMAN* dvcman = channel->dvcman;
421 HashTable_Remove(dvcman->channelsById, &channel->channel_id);
426 WINPR_ASSERT(channel);
427 DVCMAN* dvcman = channel->dvcman;
428 drdynvcPlugin* drdynvc = dvcman->drdynvc;
429 wStream* s = StreamPool_Take(dvcman->pool, 5);
433 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
434 return CHANNEL_RC_NO_MEMORY;
437 Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);
438 Stream_Write_UINT32(s, channel->channel_id);
439 return drdynvc_send(drdynvc, s);
444 WINPR_ASSERT(channel);
446 IWTSVirtualChannelCallback* cb = channel->channel_callback;
447 const char* name = channel->channel_name;
448 const UINT32
id = channel->channel_id;
451 if (!cb->OnOpen || !cb->OnClose || !cb->OnDataReceived)
452 WLog_VRB(TAG,
"{%s:%" PRIu32
"} OnOpen=%p, OnClose=%p, OnDataReceived=%p", name,
id,
453 cb->OnOpen, cb->OnClose, cb->OnDataReceived);
458 WINPR_ASSERT(channel);
461 IWTSVirtualChannelCallback* cb = channel->channel_callback;
464 check_open_close_receive(channel);
465 WINPR_ASSERT(cb->OnDataReceived);
466 return cb->OnDataReceived(cb, data);
469static UINT dvcman_channel_close(
DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn)
471 UINT error = CHANNEL_RC_OK;
472 DrdynvcClientContext* context = NULL;
474 WINPR_ASSERT(channel);
475 switch (channel->state)
477 case DVC_CHANNEL_INIT:
479 case DVC_CHANNEL_RUNNING:
482 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
483 WINPR_ASSERT(drdynvc);
484 context = drdynvc->context;
486 WLog_Print(drdynvc->log, WLOG_DEBUG,
"sending close confirm for '%s'",
487 channel->channel_name);
489 error = dvcchannel_send_close(channel);
490 if (error != CHANNEL_RC_OK)
493 WLog_Print(drdynvc->log, WLOG_DEBUG,
494 "error when sending closeRequest for '%s'",
495 channel->channel_name);
497 WLog_Print(drdynvc->log, WLOG_DEBUG,
498 "error when sending close confirm for '%s'",
499 channel->channel_name);
501 WLog_Print(drdynvc->log, WLOG_DEBUG,
"listener %s destroyed channel %" PRIu32
"",
502 channel->channel_name, channel->channel_id);
505 channel->state = DVC_CHANNEL_CLOSED;
507 IWTSVirtualChannelCallback* cb = channel->channel_callback;
510 check_open_close_receive(channel);
511 IFCALL(cb->OnClose, cb);
514 channel->channel_callback = NULL;
516 if (channel->dvcman && channel->dvcman->drdynvc)
520 IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
521 channel->pInterface);
525 if (!fromHashTableFn)
526 dvcman_channel_unref(channel);
528 case DVC_CHANNEL_CLOSED:
537static DVCMAN_CHANNEL* dvcman_channel_new(WINPR_ATTR_UNUSED drdynvcPlugin* drdynvc,
538 IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
539 const char* ChannelName)
543 WINPR_ASSERT(drdynvc);
544 WINPR_ASSERT(pChannelMgr);
550 channel->dvcman = (
DVCMAN*)pChannelMgr;
551 channel->channel_id = ChannelId;
552 channel->refCounter = 1;
553 channel->state = DVC_CHANNEL_INIT;
554 channel->channel_name = _strdup(ChannelName);
556 if (!channel->channel_name)
559 if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
564 dvcman_channel_free(channel);
568static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
572 WINPR_ASSERT(dvcman);
573 WINPR_UNUSED(drdynvc);
575 HashTable_Clear(dvcman->channelsById);
576 ArrayList_Clear(dvcman->plugins);
577 ArrayList_Clear(dvcman->plugin_names);
578 HashTable_Clear(dvcman->listeners);
580static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
584 WINPR_ASSERT(dvcman);
585 WINPR_UNUSED(drdynvc);
587 HashTable_Free(dvcman->channelsById);
588 ArrayList_Free(dvcman->plugins);
589 ArrayList_Free(dvcman->plugin_names);
590 HashTable_Free(dvcman->listeners);
592 StreamPool_Free(dvcman->pool);
601static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
604 UINT error = CHANNEL_RC_OK;
606 WINPR_ASSERT(dvcman);
607 ArrayList_Lock(dvcman->plugins);
608 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
610 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
612 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
613 if (error != CHANNEL_RC_OK)
615 WLog_Print(drdynvc->log, WLOG_ERROR,
"Initialize failed with error %" PRIu32
"!",
622 ArrayList_Unlock(dvcman->plugins);
631static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize,
const BYTE* pBuffer,
638 WINPR_UNUSED(pReserved);
639 if (!channel || !channel->dvcman)
640 return CHANNEL_RC_BAD_CHANNEL;
642 EnterCriticalSection(&(channel->lock));
644 drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize, &close);
645 LeaveCriticalSection(&(channel->lock));
648 dvcman_channel_close(channel, FALSE, FALSE);
658static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
663 return CHANNEL_RC_BAD_CHANNEL;
665 WLog_DBG(TAG,
"close_channel_iface: id=%" PRIu32
"", channel->channel_id);
666 return dvcman_channel_close(channel, FALSE, FALSE);
674static DVCMAN_CHANNEL* dvcman_create_channel(drdynvcPlugin* drdynvc,
675 IWTSVirtualChannelManager* pChannelMgr,
676 UINT32 ChannelId,
const char* ChannelName, UINT* res)
680 DrdynvcClientContext* context = NULL;
683 IWTSVirtualChannelCallback* pCallback = NULL;
685 WINPR_ASSERT(dvcman);
688 HashTable_Lock(dvcman->listeners);
689 listener = (
DVCMAN_LISTENER*)HashTable_GetItemValue(dvcman->listeners, ChannelName);
692 *res = ERROR_NOT_FOUND;
696 channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
699 switch (channel->state)
701 case DVC_CHANNEL_RUNNING:
702 WLog_Print(drdynvc->log, WLOG_ERROR,
703 "Protocol error: Duplicated ChannelId %" PRIu32
" (%s)!", ChannelId,
705 *res = CHANNEL_RC_ALREADY_OPEN;
708 case DVC_CHANNEL_CLOSED:
709 case DVC_CHANNEL_INIT:
712 WLog_Print(drdynvc->log, WLOG_ERROR,
"not expecting a createChannel from state %s",
713 channel_state2str(channel->state));
714 *res = CHANNEL_RC_INITIALIZATION_ERROR;
721 if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
723 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_channel_new failed!");
724 *res = CHANNEL_RC_NO_MEMORY;
729 if (!HashTable_Insert(dvcman->channelsById, &channel->channel_id, channel))
731 WLog_Print(drdynvc->log, WLOG_ERROR,
"unable to register channel in our channel list");
732 *res = ERROR_INTERNAL_ERROR;
733 dvcman_channel_free(channel);
738 channel->iface.Write = dvcman_write_channel;
739 channel->iface.Close = dvcman_close_channel_iface;
742 *res = listener->listener_callback->OnNewChannelConnection(
743 listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback);
745 if (*res != CHANNEL_RC_OK)
747 WLog_Print(drdynvc->log, WLOG_ERROR,
748 "OnNewChannelConnection failed with error %" PRIu32
"!", *res);
749 *res = ERROR_INTERNAL_ERROR;
750 dvcman_channel_unref(channel);
756 WLog_Print(drdynvc->log, WLOG_ERROR,
"OnNewChannelConnection returned with bAccept FALSE!");
757 *res = ERROR_INTERNAL_ERROR;
758 dvcman_channel_unref(channel);
763 WLog_Print(drdynvc->log, WLOG_DEBUG,
"listener %s created new channel %" PRIu32
"",
764 listener->channel_name, channel->channel_id);
765 channel->state = DVC_CHANNEL_RUNNING;
766 channel->channel_callback = pCallback;
767 channel->pInterface = listener->iface.pInterface;
768 context = dvcman->drdynvc->context;
770 IFCALLRET(context->OnChannelConnected, *res, context, ChannelName, listener->iface.pInterface);
771 if (*res != CHANNEL_RC_OK)
773 WLog_Print(drdynvc->log, WLOG_ERROR,
774 "context.OnChannelConnected failed with error %" PRIu32
"", *res);
778 HashTable_Unlock(dvcman->listeners);
788static UINT dvcman_open_channel(drdynvcPlugin* drdynvc,
DVCMAN_CHANNEL* channel)
790 IWTSVirtualChannelCallback* pCallback = NULL;
791 UINT error = CHANNEL_RC_OK;
793 WINPR_ASSERT(drdynvc);
794 WINPR_ASSERT(channel);
795 if (channel->state == DVC_CHANNEL_RUNNING)
797 pCallback = channel->channel_callback;
799 if (pCallback->OnOpen)
801 check_open_close_receive(channel);
802 error = pCallback->OnOpen(pCallback);
805 WLog_Print(drdynvc->log, WLOG_ERROR,
"OnOpen failed with error %" PRIu32
"!",
811 WLog_Print(drdynvc->log, WLOG_DEBUG,
"open_channel: ChannelId %" PRIu32
"",
812 channel->channel_id);
824static UINT dvcman_receive_channel_data_first(
DVCMAN_CHANNEL* channel, UINT32 length)
826 WINPR_ASSERT(channel);
827 WINPR_ASSERT(channel->dvcman);
828 if (channel->dvc_data)
829 Stream_Release(channel->dvc_data);
831 channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
833 if (!channel->dvc_data)
835 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
836 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
837 return CHANNEL_RC_NO_MEMORY;
840 channel->dvc_data_length = length;
841 return CHANNEL_RC_OK;
850 WINPR_ATTR_UNUSED UINT32 ThreadingFlags)
852 UINT status = CHANNEL_RC_OK;
853 size_t dataSize = Stream_GetRemainingLength(data);
855 WINPR_ASSERT(channel);
856 WINPR_ASSERT(channel->dvcman);
857 if (channel->dvc_data)
859 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
862 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
864 WLog_Print(drdynvc->log, WLOG_ERROR,
"data exceeding declared length!");
865 Stream_Release(channel->dvc_data);
866 channel->dvc_data = NULL;
867 status = ERROR_INVALID_DATA;
871 Stream_Copy(data, channel->dvc_data, dataSize);
873 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
875 Stream_SealLength(channel->dvc_data);
876 Stream_SetPosition(channel->dvc_data, 0);
878 status = dvcman_call_on_receive(channel, channel->dvc_data);
879 Stream_Release(channel->dvc_data);
880 channel->dvc_data = NULL;
884 status = dvcman_call_on_receive(channel, data);
890static UINT8 drdynvc_write_variable_uint(
wStream* s, UINT32 val)
897 Stream_Write_UINT8(s, (UINT8)val);
899 else if (val <= 0xFFFF)
902 Stream_Write_UINT16(s, (UINT16)val);
907 Stream_Write_UINT32(s, val);
918static UINT drdynvc_send(drdynvcPlugin* drdynvc,
wStream* s)
923 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
926 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelWriteEx);
927 status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(
928 drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),
929 (UINT32)Stream_GetPosition(s), s);
935 return CHANNEL_RC_OK;
937 case CHANNEL_RC_NOT_CONNECTED:
939 return CHANNEL_RC_OK;
941 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
943 WLog_ERR(TAG,
"VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
948 WLog_Print(drdynvc->log, WLOG_ERROR,
949 "VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
950 WTSErrorToString(status), status);
960static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId,
const BYTE* data,
961 UINT32 dataSize, BOOL* close)
967 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
971 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
973 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
974 WINPR_ASSERT(dvcman);
976 WLog_Print(drdynvc->log, WLOG_TRACE,
"write_data: ChannelId=%" PRIu32
" size=%" PRIu32
"",
977 ChannelId, dataSize);
978 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
982 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
983 return CHANNEL_RC_NO_MEMORY;
986 Stream_SetPosition(data_out, 1);
987 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
988 pos = Stream_GetPosition(data_out);
994 Stream_Release(data_out);
996 else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
998 Stream_SetPosition(data_out, 0);
999 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1000 Stream_SetPosition(data_out, pos);
1001 Stream_Write(data_out, data, dataSize);
1002 status = drdynvc_send(drdynvc, data_out);
1007 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
1008 pos = Stream_GetPosition(data_out);
1009 Stream_SetPosition(data_out, 0);
1011 const INT32 pdu = (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2);
1012 Stream_Write_UINT8(data_out, WINPR_ASSERTING_INT_CAST(UINT8, pdu));
1013 Stream_SetPosition(data_out, pos);
1016 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1017 const uint32_t chunkLength =
1018 CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1019 Stream_Write(data_out, data, chunkLength);
1021 data += chunkLength;
1022 dataSize -= chunkLength;
1024 status = drdynvc_send(drdynvc, data_out);
1026 while (status == CHANNEL_RC_OK && dataSize > 0)
1028 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
1032 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1033 return CHANNEL_RC_NO_MEMORY;
1036 Stream_SetPosition(data_out, 1);
1037 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
1038 pos = Stream_GetPosition(data_out);
1039 Stream_SetPosition(data_out, 0);
1040 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1041 Stream_SetPosition(data_out, pos);
1043 uint32_t chunkLength = dataSize;
1045 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1046 if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)
1047 chunkLength = CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1049 Stream_Write(data_out, data, chunkLength);
1050 data += chunkLength;
1051 dataSize -= chunkLength;
1052 status = drdynvc_send(drdynvc, data_out);
1056 if (status != CHANNEL_RC_OK)
1058 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1059 WTSErrorToString(status), status);
1063 return CHANNEL_RC_OK;
1071static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
1078 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1080 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1081 WINPR_ASSERT(dvcman);
1083 WLog_Print(drdynvc->log, WLOG_TRACE,
"capability_response");
1084 s = StreamPool_Take(dvcman->pool, 4);
1088 WLog_Print(drdynvc->log, WLOG_ERROR,
"Stream_Ndrdynvc_write_variable_uintew failed!");
1089 return CHANNEL_RC_NO_MEMORY;
1092 Stream_Write_UINT16(s, 0x0050);
1093 Stream_Write_UINT16(s, drdynvc->version);
1094 status = drdynvc_send(drdynvc, s);
1096 if (status != CHANNEL_RC_OK)
1098 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1099 WTSErrorToString(status), status);
1110static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
1116 return CHANNEL_RC_BAD_INIT_HANDLE;
1118 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
1119 return ERROR_INVALID_DATA;
1121 WLog_Print(drdynvc->log, WLOG_TRACE,
"capability_request Sp=%d cbChId=%d", Sp, cbChId);
1123 Stream_Read_UINT16(s, drdynvc->version);
1128 if ((drdynvc->version == 2) || (drdynvc->version == 3))
1130 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1131 return ERROR_INVALID_DATA;
1133 Stream_Read_UINT16(s, drdynvc->PriorityCharge0);
1134 Stream_Read_UINT16(s, drdynvc->PriorityCharge1);
1135 Stream_Read_UINT16(s, drdynvc->PriorityCharge2);
1136 Stream_Read_UINT16(s, drdynvc->PriorityCharge3);
1139 status = drdynvc_send_capability_response(drdynvc);
1140 drdynvc->state = DRDYNVC_STATE_READY;
1144static UINT32 drdynvc_cblen_to_bytes(
int cbLen)
1159static UINT32 drdynvc_read_variable_uint(
wStream* s,
int cbLen)
1166 Stream_Read_UINT8(s, val);
1170 Stream_Read_UINT16(s, val);
1174 Stream_Read_UINT32(s, val);
1186static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, UINT8 Sp, UINT8 cbChId,
1191 UINT channel_status = 0;
1194 INT32 retStatus = 0;
1198 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1200 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1201 WINPR_ASSERT(dvcman);
1203 if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1210 drdynvc->version = 3;
1212 if ((status = drdynvc_send_capability_response(drdynvc)))
1214 WLog_Print(drdynvc->log, WLOG_ERROR,
"drdynvc_send_capability_response failed!");
1218 drdynvc->state = DRDYNVC_STATE_READY;
1221 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1222 return ERROR_INVALID_DATA;
1224 const UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1225 const size_t pos = Stream_GetPosition(s);
1226 const char* name = Stream_ConstPointer(s);
1227 const size_t length = Stream_GetRemainingLength(s);
1229 if (strnlen(name, length) >= length)
1230 return ERROR_INVALID_DATA;
1232 WLog_Print(drdynvc->log, WLOG_DEBUG,
1233 "process_create_request: ChannelId=%" PRIu32
" ChannelName=%s", ChannelId, name);
1235 data_out = StreamPool_Take(dvcman->pool, pos + 4);
1238 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1239 return CHANNEL_RC_NO_MEMORY;
1242 Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1243 Stream_SetPosition(s, 1);
1244 Stream_Copy(s, data_out, pos - 1);
1247 dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name, &channel_status);
1248 switch (channel_status)
1251 WLog_Print(drdynvc->log, WLOG_DEBUG,
"channel created");
1254 case CHANNEL_RC_NO_MEMORY:
1255 WLog_Print(drdynvc->log, WLOG_DEBUG,
"not enough memory for channel creation");
1256 retStatus = STATUS_NO_MEMORY;
1258 case ERROR_NOT_FOUND:
1259 WLog_Print(drdynvc->log, WLOG_DEBUG,
"no listener for '%s'", name);
1260 retStatus = STATUS_NOT_FOUND;
1263 WLog_Print(drdynvc->log, WLOG_DEBUG,
"channel creation error");
1264 retStatus = STATUS_UNSUCCESSFUL;
1267 Stream_Write_INT32(data_out, retStatus);
1269 status = drdynvc_send(drdynvc, data_out);
1270 if (status != CHANNEL_RC_OK)
1272 WLog_Print(drdynvc->log, WLOG_ERROR,
"VirtualChannelWriteEx failed with %s [%08" PRIX32
"]",
1273 WTSErrorToString(status), status);
1274 dvcman_channel_unref(channel);
1278 if (channel_status == CHANNEL_RC_OK)
1280 if ((status = dvcman_open_channel(drdynvc, channel)))
1282 WLog_Print(drdynvc->log, WLOG_ERROR,
1283 "dvcman_open_channel failed with error %" PRIu32
"!", status);
1296static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s,
1297 UINT32 ThreadingFlags)
1299 UINT status = CHANNEL_RC_OK;
1301 UINT32 ChannelId = 0;
1304 WINPR_ASSERT(drdynvc);
1305 if (!Stream_CheckAndLogRequiredLength(
1306 TAG, s, drdynvc_cblen_to_bytes(cbChId) + drdynvc_cblen_to_bytes(Sp)))
1307 return ERROR_INVALID_DATA;
1309 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1310 Length = drdynvc_read_variable_uint(s, Sp);
1311 WLog_Print(drdynvc->log, WLOG_TRACE,
1312 "process_data_first: Sp=%d cbChId=%d, ChannelId=%" PRIu32
" Length=%" PRIu32
"", Sp,
1313 cbChId, ChannelId, Length);
1315 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1323 WLog_Print(drdynvc->log, WLOG_ERROR,
"ChannelId %" PRIu32
" not found!", ChannelId);
1324 return CHANNEL_RC_OK;
1327 if (channel->state != DVC_CHANNEL_RUNNING)
1330 status = dvcman_receive_channel_data_first(channel, Length);
1332 if (status == CHANNEL_RC_OK)
1333 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1335 if (status != CHANNEL_RC_OK)
1336 status = dvcman_channel_close(channel, FALSE, FALSE);
1339 dvcman_channel_unref(channel);
1348static UINT drdynvc_process_data(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s,
1349 UINT32 ThreadingFlags)
1351 UINT32 ChannelId = 0;
1353 UINT status = CHANNEL_RC_OK;
1355 WINPR_ASSERT(drdynvc);
1356 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1357 return ERROR_INVALID_DATA;
1359 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1360 WLog_Print(drdynvc->log, WLOG_TRACE,
"process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32
"", Sp,
1363 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1371 WLog_Print(drdynvc->log, WLOG_ERROR,
"ChannelId %" PRIu32
" not found!", ChannelId);
1372 return CHANNEL_RC_OK;
1375 if (channel->state != DVC_CHANNEL_RUNNING)
1378 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1379 if (status != CHANNEL_RC_OK)
1380 status = dvcman_channel_close(channel, FALSE, FALSE);
1383 dvcman_channel_unref(channel);
1392static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc,
int Sp,
int cbChId,
wStream* s)
1394 UINT32 ChannelId = 0;
1397 WINPR_ASSERT(drdynvc);
1398 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1399 return ERROR_INVALID_DATA;
1401 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1402 WLog_Print(drdynvc->log, WLOG_DEBUG,
1403 "process_close_request: Sp=%d cbChId=%d, ChannelId=%" PRIu32
"", Sp, cbChId,
1406 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1409 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_close_request channel %" PRIu32
" not present",
1411 return CHANNEL_RC_OK;
1414 dvcman_channel_close(channel, TRUE, FALSE);
1415 dvcman_channel_unref(channel);
1416 return CHANNEL_RC_OK;
1424static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc,
wStream* s, UINT32 ThreadingFlags)
1428 WINPR_ASSERT(drdynvc);
1429 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1430 return ERROR_INVALID_DATA;
1432 Stream_Read_UINT8(s, value);
1433 const UINT8 Cmd = (value & 0xf0) >> 4;
1434 const UINT8 Sp = (value & 0x0c) >> 2;
1435 const UINT8 cbChId = (value & 0x03) >> 0;
1436 WLog_Print(drdynvc->log, WLOG_TRACE,
"order_recv: Cmd=%s, Sp=%" PRIu8
" cbChId=%" PRIu8,
1437 drdynvc_get_packet_type(Cmd), Sp, cbChId);
1441 case CAPABILITY_REQUEST_PDU:
1442 return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1444 case CREATE_REQUEST_PDU:
1445 return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1447 case DATA_FIRST_PDU:
1448 return drdynvc_process_data_first(drdynvc, Sp, cbChId, s, ThreadingFlags);
1451 return drdynvc_process_data(drdynvc, Sp, cbChId, s, ThreadingFlags);
1453 case CLOSE_REQUEST_PDU:
1454 return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1457 WLog_Print(drdynvc->log, WLOG_ERROR,
"unknown drdynvc cmd 0x%x", Cmd);
1458 return ERROR_INTERNAL_ERROR;
1467static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc,
void* pData,
1468 UINT32 dataLength, UINT32 totalLength,
1473 WINPR_ASSERT(drdynvc);
1474 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1476 return CHANNEL_RC_OK;
1479 if (dataFlags & CHANNEL_FLAG_FIRST)
1482 if (drdynvc->data_in)
1483 Stream_Release(drdynvc->data_in);
1485 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1488 if (!(data_in = drdynvc->data_in))
1490 WLog_Print(drdynvc->log, WLOG_ERROR,
"StreamPool_Take failed!");
1491 return CHANNEL_RC_NO_MEMORY;
1494 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1496 WLog_Print(drdynvc->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
1497 Stream_Release(drdynvc->data_in);
1498 drdynvc->data_in = NULL;
1499 return ERROR_INTERNAL_ERROR;
1502 Stream_Write(data_in, pData, dataLength);
1504 if (dataFlags & CHANNEL_FLAG_LAST)
1506 const size_t cap = Stream_Capacity(data_in);
1507 const size_t pos = Stream_GetPosition(data_in);
1510 WLog_Print(drdynvc->log, WLOG_ERROR,
"drdynvc_plugin_process_received: read error");
1511 return ERROR_INVALID_DATA;
1514 drdynvc->data_in = NULL;
1515 Stream_SealLength(data_in);
1516 Stream_SetPosition(data_in, 0);
1520 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (
void*)data_in, NULL))
1522 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Post failed!");
1523 return ERROR_INTERNAL_ERROR;
1528 UINT error = drdynvc_order_recv(drdynvc, data_in, TRUE);
1529 Stream_Release(data_in);
1533 WLog_Print(drdynvc->log, WLOG_WARN,
1534 "drdynvc_order_recv failed with error %" PRIu32
"!", error);
1539 return CHANNEL_RC_OK;
1542static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1543 UINT event, LPVOID pData,
1544 UINT32 dataLength, UINT32 totalLength,
1547 UINT error = CHANNEL_RC_OK;
1548 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1550 WINPR_ASSERT(drdynvc);
1553 case CHANNEL_EVENT_DATA_RECEIVED:
1554 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1556 WLog_ERR(TAG,
"drdynvc_virtual_channel_open_event: error no match");
1559 if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1560 totalLength, dataFlags)))
1561 WLog_Print(drdynvc->log, WLOG_ERROR,
1562 "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1568 case CHANNEL_EVENT_WRITE_CANCELLED:
1569 case CHANNEL_EVENT_WRITE_COMPLETE:
1576 case CHANNEL_EVENT_USER:
1582 if (error && drdynvc && drdynvc->rdpcontext)
1583 setChannelError(drdynvc->rdpcontext, error,
1584 "drdynvc_virtual_channel_open_event reported an error");
1587static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1591 wMessage message = { 0 };
1592 UINT error = CHANNEL_RC_OK;
1593 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1597 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1598 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1603 if (!MessageQueue_Wait(drdynvc->queue))
1605 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Wait failed!");
1606 error = ERROR_INTERNAL_ERROR;
1610 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1612 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_Peek failed!");
1613 error = ERROR_INTERNAL_ERROR;
1617 if (message.id == WMQ_QUIT)
1620 if (message.id == 0)
1622 UINT32 ThreadingFlags = TRUE;
1623 data = (
wStream*)message.wParam;
1625 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1627 WLog_Print(drdynvc->log, WLOG_WARN,
1628 "drdynvc_order_recv failed with error %" PRIu32
"!", error);
1631 Stream_Release(data);
1641 HashTable_Clear(drdynvcMgr->channelsById);
1644 if (error && drdynvc->rdpcontext)
1645 setChannelError(drdynvc->rdpcontext, error,
1646 "drdynvc_virtual_channel_client_thread reported an error");
1648 ExitThread((DWORD)error);
1652static void drdynvc_queue_object_free(
void* obj)
1655 wMessage* msg = (wMessage*)obj;
1657 if (!msg || (msg->id != 0))
1666static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1670 WINPR_UNUSED(pData);
1671 WINPR_UNUSED(dataLength);
1676 drdynvc->queue = MessageQueue_New(NULL);
1678 if (!drdynvc->queue)
1680 WLog_Print(drdynvc->log, WLOG_ERROR,
"MessageQueue_New failed!");
1684 obj = MessageQueue_Object(drdynvc->queue);
1685 obj->fnObjectFree = drdynvc_queue_object_free;
1686 drdynvc->channel_mgr = dvcman_new(drdynvc);
1688 if (!drdynvc->channel_mgr)
1690 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_new failed!");
1694 return CHANNEL_RC_OK;
1696 return ERROR_INTERNAL_ERROR;
1704static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1709 rdpSettings* settings = NULL;
1711 WINPR_ASSERT(drdynvc);
1712 WINPR_UNUSED(pData);
1713 WINPR_UNUSED(dataLength);
1716 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1718 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelOpenEx);
1719 status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1720 drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1721 drdynvc_virtual_channel_open_event_ex);
1723 if (status != CHANNEL_RC_OK)
1725 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelOpen failed with %s [%08" PRIX32
"]",
1726 WTSErrorToString(status), status);
1730 WINPR_ASSERT(drdynvc->rdpcontext);
1731 settings = drdynvc->rdpcontext->settings;
1732 WINPR_ASSERT(settings);
1734 for (UINT32 index = 0;
1738 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1739 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1741 if (CHANNEL_RC_OK != error)
1745 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1747 WLog_Print(drdynvc->log, WLOG_ERROR,
"dvcman_init failed with error %" PRIu32
"!", error);
1751 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1755 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1756 (
void*)drdynvc, 0, NULL)))
1758 error = ERROR_INTERNAL_ERROR;
1759 WLog_Print(drdynvc->log, WLOG_ERROR,
"CreateThread failed!");
1763 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1764 WLog_Print(drdynvc->log, WLOG_WARN,
"SetThreadPriority failed, ignoring.");
1776static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1781 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1783 if (drdynvc->OpenHandle == 0)
1784 return CHANNEL_RC_OK;
1788 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1790 status = GetLastError();
1791 WLog_Print(drdynvc->log, WLOG_ERROR,
1792 "MessageQueue_PostQuit failed with error %" PRIu32
"", status);
1797 if (drdynvc->thread)
1799 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1801 status = GetLastError();
1802 WLog_Print(drdynvc->log, WLOG_ERROR,
1803 "WaitForSingleObject failed with error %" PRIu32
"", status);
1807 (void)CloseHandle(drdynvc->thread);
1808 drdynvc->thread = NULL;
1818 HashTable_Clear(drdynvcMgr->channelsById);
1822 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1823 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1824 drdynvc->OpenHandle);
1826 if (status != CHANNEL_RC_OK)
1828 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelClose failed with %s [%08" PRIX32
"]",
1829 WTSErrorToString(status), status);
1832 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1834 MessageQueue_Clear(drdynvc->queue);
1835 drdynvc->OpenHandle = 0;
1837 if (drdynvc->data_in)
1839 Stream_Release(drdynvc->data_in);
1840 drdynvc->data_in = NULL;
1851static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1854 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1856 MessageQueue_Free(drdynvc->queue);
1857 drdynvc->queue = NULL;
1859 if (drdynvc->channel_mgr)
1861 dvcman_free(drdynvc, drdynvc->channel_mgr);
1862 drdynvc->channel_mgr = NULL;
1864 drdynvc->InitHandle = 0;
1865 free(drdynvc->context);
1867 return CHANNEL_RC_OK;
1870static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1872 UINT error = CHANNEL_RC_OK;
1876 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1878 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1881 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1883 ArrayList_Lock(dvcman->plugins);
1884 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1886 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1888 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1889 if (error != CHANNEL_RC_OK)
1891 WLog_Print(drdynvc->log, WLOG_ERROR,
"Attach failed with error %" PRIu32
"!", error);
1897 ArrayList_Unlock(dvcman->plugins);
1901static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1903 UINT error = CHANNEL_RC_OK;
1907 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1909 dvcman = (
DVCMAN*)drdynvc->channel_mgr;
1912 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1914 ArrayList_Lock(dvcman->plugins);
1915 for (
size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1917 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1919 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1920 if (error != CHANNEL_RC_OK)
1922 WLog_Print(drdynvc->log, WLOG_ERROR,
"Detach failed with error %" PRIu32
"!", error);
1928 ArrayList_Unlock(dvcman->plugins);
1933static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1934 UINT event, LPVOID pData,
1937 UINT error = CHANNEL_RC_OK;
1938 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1940 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
1942 WLog_ERR(TAG,
"drdynvc_virtual_channel_init_event: error no match");
1948 case CHANNEL_EVENT_INITIALIZED:
1949 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
1951 case CHANNEL_EVENT_CONNECTED:
1952 if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
1953 WLog_Print(drdynvc->log, WLOG_ERROR,
1954 "drdynvc_virtual_channel_event_connected failed with error %" PRIu32
"",
1959 case CHANNEL_EVENT_DISCONNECTED:
1960 if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
1961 WLog_Print(drdynvc->log, WLOG_ERROR,
1962 "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
1968 case CHANNEL_EVENT_TERMINATED:
1969 if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
1970 WLog_Print(drdynvc->log, WLOG_ERROR,
1971 "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32
"",
1976 case CHANNEL_EVENT_ATTACHED:
1977 if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
1978 WLog_Print(drdynvc->log, WLOG_ERROR,
1979 "drdynvc_virtual_channel_event_attached failed with error %" PRIu32
"",
1984 case CHANNEL_EVENT_DETACHED:
1985 if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
1986 WLog_Print(drdynvc->log, WLOG_ERROR,
1987 "drdynvc_virtual_channel_event_detached failed with error %" PRIu32
"",
1996 if (error && drdynvc->rdpcontext)
1997 setChannelError(drdynvc->rdpcontext, error,
1998 "drdynvc_virtual_channel_init_event_ex reported an error");
2005static int drdynvc_get_version(DrdynvcClientContext* context)
2007 WINPR_ASSERT(context);
2008 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
2009 WINPR_ASSERT(drdynvc);
2010 return drdynvc->version;
2014#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
2016FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2020 drdynvcPlugin* drdynvc = NULL;
2021 DrdynvcClientContext* context = NULL;
2023 drdynvc = (drdynvcPlugin*)calloc(1,
sizeof(drdynvcPlugin));
2025 WINPR_ASSERT(pEntryPoints);
2028 WLog_ERR(TAG,
"calloc failed!");
2032 drdynvc->channelDef.options =
2033 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2034 (void)sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name),
2035 DRDYNVC_SVC_CHANNEL_NAME);
2036 drdynvc->state = DRDYNVC_STATE_INITIAL;
2040 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2042 context = (DrdynvcClientContext*)calloc(1,
sizeof(DrdynvcClientContext));
2046 WLog_Print(drdynvc->log, WLOG_ERROR,
"calloc failed!");
2051 context->handle = (
void*)drdynvc;
2052 context->custom = NULL;
2053 drdynvc->context = context;
2054 context->GetVersion = drdynvc_get_version;
2055 drdynvc->rdpcontext = pEntryPointsEx->context;
2057 FreeRDP_TransportDumpReplay) &&
2059 FreeRDP_SynchronousDynamicChannels))
2060 drdynvc->async = TRUE;
2063 drdynvc->log = WLog_Get(TAG);
2064 WLog_Print(drdynvc->log, WLOG_DEBUG,
"VirtualChannelEntryEx");
2065 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2067 drdynvc->InitHandle = pInitHandle;
2069 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelInitEx);
2070 rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
2071 drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2072 drdynvc_virtual_channel_init_event_ex);
2074 if (CHANNEL_RC_OK != rc)
2076 WLog_Print(drdynvc->log, WLOG_ERROR,
"pVirtualChannelInit failed with %s [%08" PRIX32
"]",
2077 WTSErrorToString(rc), rc);
2078 free(drdynvc->context);
2083 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.