FreeRDP
Loading...
Searching...
No Matches
client/drdynvc_main.c
1
22#include <freerdp/config.h>
23
24#include <winpr/crt.h>
25#include <winpr/cast.h>
26#include <winpr/stream.h>
27#include <winpr/interlocked.h>
28
29#include <freerdp/freerdp.h>
30#include <freerdp/channels/drdynvc.h>
31#include <freerdp/utils/drdynvc.h>
32
33#include "drdynvc_main.h"
34
35#define TAG CHANNELS_TAG("drdynvc.client")
36
37static const char* channel_state2str(DVC_CHANNEL_STATE state)
38{
39 switch (state)
40 {
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";
47 default:
48 return "DVC_CHANNEL_UNKNOWN";
49 }
50}
51
52static void dvcman_channel_free(DVCMAN_CHANNEL* channel);
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);
58
59static void dvcman_wtslistener_free(DVCMAN_LISTENER* listener)
60{
61 if (listener)
62 free(listener->channel_name);
63 free(listener);
64}
65
71static UINT dvcman_get_configuration(IWTSListener* pListener, void** ppPropertyBag)
72{
73 WINPR_ASSERT(ppPropertyBag);
74 WINPR_UNUSED(pListener);
75 *ppPropertyBag = NULL;
76 return ERROR_INTERNAL_ERROR;
77}
78
84static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
85 const char* pszChannelName, ULONG ulFlags,
86 IWTSListenerCallback* pListenerCallback,
87 IWTSListener** ppListener)
88{
89 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
90 DVCMAN_LISTENER* listener = NULL;
91
92 WINPR_ASSERT(dvcman);
93 WLog_DBG(TAG, "create_listener: %" PRIuz ".%s.", HashTable_Count(dvcman->listeners) + 1,
94 pszChannelName);
95 listener = (DVCMAN_LISTENER*)calloc(1, sizeof(DVCMAN_LISTENER));
96
97 if (!listener)
98 {
99 WLog_ERR(TAG, "calloc failed!");
100 return CHANNEL_RC_NO_MEMORY;
101 }
102
103 listener->iface.GetConfiguration = dvcman_get_configuration;
104 listener->iface.pInterface = NULL;
105 listener->dvcman = dvcman;
106 listener->channel_name = _strdup(pszChannelName);
107
108 if (!listener->channel_name)
109 {
110 WLog_ERR(TAG, "_strdup failed!");
111 dvcman_wtslistener_free(listener);
112 return CHANNEL_RC_NO_MEMORY;
113 }
114
115 listener->flags = ulFlags;
116 listener->listener_callback = pListenerCallback;
117
118 if (ppListener)
119 *ppListener = (IWTSListener*)listener;
120
121 if (!HashTable_Insert(dvcman->listeners, listener->channel_name, listener))
122 {
123 dvcman_wtslistener_free(listener);
124 return ERROR_INTERNAL_ERROR;
125 }
126
127 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of listener
128 return CHANNEL_RC_OK;
129}
130
131static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)
132{
133 DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)pListener;
134
135 WINPR_UNUSED(pChannelMgr);
136
137 if (listener)
138 {
139 DVCMAN* dvcman = listener->dvcman;
140 if (dvcman)
141 HashTable_Remove(dvcman->listeners, listener->channel_name);
142 }
143
144 return CHANNEL_RC_OK;
145}
146
152static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name,
153 IWTSPlugin* pPlugin)
154{
155 WINPR_ASSERT(pEntryPoints);
156 DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
157
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;
163
164 WLog_DBG(TAG, "register_plugin: num_plugins %" PRIuz, ArrayList_Count(dvcman->plugins));
165 return CHANNEL_RC_OK;
166}
167
168static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name)
169{
170 IWTSPlugin* plugin = NULL;
171 size_t nc = 0;
172 size_t pc = 0;
173 WINPR_ASSERT(pEntryPoints);
174 DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
175 if (!dvcman || !pEntryPoints || !name)
176 return NULL;
177
178 nc = ArrayList_Count(dvcman->plugin_names);
179 pc = ArrayList_Count(dvcman->plugins);
180 if (nc != pc)
181 return NULL;
182
183 ArrayList_Lock(dvcman->plugin_names);
184 ArrayList_Lock(dvcman->plugins);
185 for (size_t i = 0; i < pc; i++)
186 {
187 const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);
188 if (strcmp(cur, name) == 0)
189 {
190 plugin = ArrayList_GetItem(dvcman->plugins, i);
191 break;
192 }
193 }
194 ArrayList_Unlock(dvcman->plugin_names);
195 ArrayList_Unlock(dvcman->plugins);
196 return plugin;
197}
198
199static const ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
200{
201 WINPR_ASSERT(pEntryPoints);
202 return ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->args;
203}
204
205static rdpContext* dvcman_get_rdp_context(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
206{
207 DVCMAN_ENTRY_POINTS* entry = (DVCMAN_ENTRY_POINTS*)pEntryPoints;
208 WINPR_ASSERT(entry);
209 return entry->context;
210}
211
212static rdpSettings* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
213{
214 rdpContext* context = dvcman_get_rdp_context(pEntryPoints);
215 WINPR_ASSERT(context);
216
217 return context->settings;
218}
219
220static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)
221{
222 DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
223 WINPR_ASSERT(dvc);
224 return dvc->channel_id;
225}
226
227static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)
228{
229 DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
230 WINPR_ASSERT(dvc);
231 return dvc->channel_name;
232}
233
234static DVCMAN_CHANNEL* dvcman_get_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
235 UINT32 ChannelId, BOOL doRef)
236{
237 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
238 DVCMAN_CHANNEL* dvcChannel = NULL;
239
240 WINPR_ASSERT(dvcman);
241 HashTable_Lock(dvcman->channelsById);
242 dvcChannel = HashTable_GetItemValue(dvcman->channelsById, &ChannelId);
243 if (dvcChannel)
244 {
245 if (doRef)
246 InterlockedIncrement(&dvcChannel->refCounter);
247 }
248
249 HashTable_Unlock(dvcman->channelsById);
250 return dvcChannel;
251}
252
253static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
254 UINT32 ChannelId)
255{
256 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
257 if (!channel)
258 return NULL;
259
260 return &channel->iface;
261}
262
263static void dvcman_plugin_terminate(void* plugin)
264{
265 IWTSPlugin* pPlugin = plugin;
266
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);
271}
272
273static void wts_listener_free(void* arg)
274{
275 DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)arg;
276 dvcman_wtslistener_free(listener);
277}
278
279static BOOL channelIdMatch(const void* k1, const void* k2)
280{
281 WINPR_ASSERT(k1);
282 WINPR_ASSERT(k2);
283 return *((const UINT32*)k1) == *((const UINT32*)k2);
284}
285
286static UINT32 channelIdHash(const void* id)
287{
288 WINPR_ASSERT(id);
289 return *((const UINT32*)id);
290}
291
292static void channelByIdCleanerFn(void* value)
293{
294 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)value;
295 if (channel)
296 {
297 dvcman_channel_close(channel, FALSE, TRUE);
298 dvcman_channel_free(channel);
299 }
300}
301
302static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)
303{
304 wObject* obj = NULL;
305 DVCMAN* dvcman = (DVCMAN*)calloc(1, sizeof(DVCMAN));
306
307 if (!dvcman)
308 return NULL;
309
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);
317
318 if (!dvcman->channelsById)
319 goto fail;
320
321 HashTable_SetHashFunction(dvcman->channelsById, channelIdHash);
322 obj = HashTable_KeyObject(dvcman->channelsById);
323 WINPR_ASSERT(obj);
324 obj->fnObjectEquals = channelIdMatch;
325
326 obj = HashTable_ValueObject(dvcman->channelsById);
327 WINPR_ASSERT(obj);
328 obj->fnObjectFree = channelByIdCleanerFn;
329
330 dvcman->pool = StreamPool_New(TRUE, 10);
331 if (!dvcman->pool)
332 goto fail;
333
334 dvcman->listeners = HashTable_New(TRUE);
335 if (!dvcman->listeners)
336 goto fail;
337 HashTable_SetHashFunction(dvcman->listeners, HashTable_StringHash);
338
339 obj = HashTable_KeyObject(dvcman->listeners);
340 obj->fnObjectEquals = HashTable_StringCompare;
341
342 obj = HashTable_ValueObject(dvcman->listeners);
343 obj->fnObjectFree = wts_listener_free;
344
345 dvcman->plugin_names = ArrayList_New(TRUE);
346 if (!dvcman->plugin_names)
347 goto fail;
348 obj = ArrayList_Object(dvcman->plugin_names);
349 obj->fnObjectNew = winpr_ObjectStringClone;
350 obj->fnObjectFree = winpr_ObjectStringFree;
351
352 dvcman->plugins = ArrayList_New(TRUE);
353 if (!dvcman->plugins)
354 goto fail;
355 obj = ArrayList_Object(dvcman->plugins);
356 obj->fnObjectFree = dvcman_plugin_terminate;
357 return &dvcman->iface;
358fail:
359 dvcman_free(plugin, &dvcman->iface);
360 return NULL;
361}
362
368static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
369 const ADDIN_ARGV* args, rdpContext* context)
370{
371 WINPR_ASSERT(drdynvc);
372 WINPR_ASSERT(pChannelMgr);
373 WINPR_ASSERT(args);
374 WINPR_ASSERT(context);
375
376 WLog_Print(drdynvc->log, WLOG_INFO, "Loading Dynamic Virtual Channel %s", args->argv[0]);
377
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);
381
382 if (pDVCPluginEntry)
383 {
384 DVCMAN_ENTRY_POINTS entryPoints = { 0 };
385
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);
395 }
396
397 return ERROR_INVALID_FUNCTION;
398}
399
400static void dvcman_channel_free(DVCMAN_CHANNEL* channel)
401{
402 if (!channel)
403 return;
404
405 if (channel->dvc_data)
406 Stream_Release(channel->dvc_data);
407
408 DeleteCriticalSection(&(channel->lock));
409 free(channel->channel_name);
410 free(channel);
411}
412
413static void dvcman_channel_unref(DVCMAN_CHANNEL* channel)
414{
415 WINPR_ASSERT(channel);
416 if (InterlockedDecrement(&channel->refCounter))
417 return;
418
419 DVCMAN* dvcman = channel->dvcman;
420 if (dvcman)
421 HashTable_Remove(dvcman->channelsById, &channel->channel_id);
422}
423
424static UINT dvcchannel_send_close(DVCMAN_CHANNEL* channel)
425{
426 WINPR_ASSERT(channel);
427 DVCMAN* dvcman = channel->dvcman;
428 drdynvcPlugin* drdynvc = dvcman->drdynvc;
429 wStream* s = StreamPool_Take(dvcman->pool, 5);
430
431 if (!s)
432 {
433 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
434 return CHANNEL_RC_NO_MEMORY;
435 }
436
437 Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);
438 Stream_Write_UINT32(s, channel->channel_id);
439 return drdynvc_send(drdynvc, s);
440}
441
442static void check_open_close_receive(DVCMAN_CHANNEL* channel)
443{
444 WINPR_ASSERT(channel);
445
446 IWTSVirtualChannelCallback* cb = channel->channel_callback;
447 const char* name = channel->channel_name;
448 const UINT32 id = channel->channel_id;
449
450 WINPR_ASSERT(cb);
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);
454}
455
456static UINT dvcman_call_on_receive(DVCMAN_CHANNEL* channel, wStream* data)
457{
458 WINPR_ASSERT(channel);
459 WINPR_ASSERT(data);
460
461 IWTSVirtualChannelCallback* cb = channel->channel_callback;
462 WINPR_ASSERT(cb);
463
464 check_open_close_receive(channel);
465 WINPR_ASSERT(cb->OnDataReceived);
466 return cb->OnDataReceived(cb, data);
467}
468
469static UINT dvcman_channel_close(DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn)
470{
471 UINT error = CHANNEL_RC_OK;
472 DrdynvcClientContext* context = NULL;
473
474 WINPR_ASSERT(channel);
475 switch (channel->state)
476 {
477 case DVC_CHANNEL_INIT:
478 break;
479 case DVC_CHANNEL_RUNNING:
480 if (channel->dvcman)
481 {
482 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
483 WINPR_ASSERT(drdynvc);
484 context = drdynvc->context;
485 if (perRequest)
486 WLog_Print(drdynvc->log, WLOG_DEBUG, "sending close confirm for '%s'",
487 channel->channel_name);
488
489 error = dvcchannel_send_close(channel);
490 if (error != CHANNEL_RC_OK)
491 {
492 if (perRequest)
493 WLog_Print(drdynvc->log, WLOG_DEBUG,
494 "error when sending closeRequest for '%s'",
495 channel->channel_name);
496 else
497 WLog_Print(drdynvc->log, WLOG_DEBUG,
498 "error when sending close confirm for '%s'",
499 channel->channel_name);
500 }
501 WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s destroyed channel %" PRIu32 "",
502 channel->channel_name, channel->channel_id);
503 }
504
505 channel->state = DVC_CHANNEL_CLOSED;
506
507 IWTSVirtualChannelCallback* cb = channel->channel_callback;
508 if (cb)
509 {
510 check_open_close_receive(channel);
511 IFCALL(cb->OnClose, cb);
512 }
513
514 channel->channel_callback = NULL;
515
516 if (channel->dvcman && channel->dvcman->drdynvc)
517 {
518 if (context)
519 {
520 IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
521 channel->pInterface);
522 }
523 }
524
525 if (!fromHashTableFn)
526 dvcman_channel_unref(channel);
527 break;
528 case DVC_CHANNEL_CLOSED:
529 break;
530 default:
531 break;
532 }
533
534 return error;
535}
536
537static DVCMAN_CHANNEL* dvcman_channel_new(WINPR_ATTR_UNUSED drdynvcPlugin* drdynvc,
538 IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
539 const char* ChannelName)
540{
541 DVCMAN_CHANNEL* channel = NULL;
542
543 WINPR_ASSERT(drdynvc);
544 WINPR_ASSERT(pChannelMgr);
545 channel = (DVCMAN_CHANNEL*)calloc(1, sizeof(DVCMAN_CHANNEL));
546
547 if (!channel)
548 return NULL;
549
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);
555
556 if (!channel->channel_name)
557 goto fail;
558
559 if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
560 goto fail;
561
562 return channel;
563fail:
564 dvcman_channel_free(channel);
565 return NULL;
566}
567
568static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
569{
570 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
571
572 WINPR_ASSERT(dvcman);
573 WINPR_UNUSED(drdynvc);
574
575 HashTable_Clear(dvcman->channelsById);
576 ArrayList_Clear(dvcman->plugins);
577 ArrayList_Clear(dvcman->plugin_names);
578 HashTable_Clear(dvcman->listeners);
579}
580static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
581{
582 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
583
584 WINPR_ASSERT(dvcman);
585 WINPR_UNUSED(drdynvc);
586
587 HashTable_Free(dvcman->channelsById);
588 ArrayList_Free(dvcman->plugins);
589 ArrayList_Free(dvcman->plugin_names);
590 HashTable_Free(dvcman->listeners);
591
592 StreamPool_Free(dvcman->pool);
593 free(dvcman);
594}
595
601static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
602{
603 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
604 UINT error = CHANNEL_RC_OK;
605
606 WINPR_ASSERT(dvcman);
607 ArrayList_Lock(dvcman->plugins);
608 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
609 {
610 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
611
612 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
613 if (error != CHANNEL_RC_OK)
614 {
615 WLog_Print(drdynvc->log, WLOG_ERROR, "Initialize failed with error %" PRIu32 "!",
616 error);
617 goto fail;
618 }
619 }
620
621fail:
622 ArrayList_Unlock(dvcman->plugins);
623 return error;
624}
625
631static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize, const BYTE* pBuffer,
632 void* pReserved)
633{
634 BOOL close = FALSE;
635 UINT status = 0;
636 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
637
638 WINPR_UNUSED(pReserved);
639 if (!channel || !channel->dvcman)
640 return CHANNEL_RC_BAD_CHANNEL;
641
642 EnterCriticalSection(&(channel->lock));
643 status =
644 drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize, &close);
645 LeaveCriticalSection(&(channel->lock));
646 /* Close delayed, it removes the channel struct */
647 if (close)
648 dvcman_channel_close(channel, FALSE, FALSE);
649
650 return status;
651}
652
658static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
659{
660 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
661
662 if (!channel)
663 return CHANNEL_RC_BAD_CHANNEL;
664
665 WLog_DBG(TAG, "close_channel_iface: id=%" PRIu32 "", channel->channel_id);
666 return dvcman_channel_close(channel, FALSE, FALSE);
667}
668
674static DVCMAN_CHANNEL* dvcman_create_channel(drdynvcPlugin* drdynvc,
675 IWTSVirtualChannelManager* pChannelMgr,
676 UINT32 ChannelId, const char* ChannelName, UINT* res)
677{
678 BOOL bAccept = 0;
679 DVCMAN_CHANNEL* channel = NULL;
680 DrdynvcClientContext* context = NULL;
681 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
682 DVCMAN_LISTENER* listener = NULL;
683 IWTSVirtualChannelCallback* pCallback = NULL;
684
685 WINPR_ASSERT(dvcman);
686 WINPR_ASSERT(res);
687
688 HashTable_Lock(dvcman->listeners);
689 listener = (DVCMAN_LISTENER*)HashTable_GetItemValue(dvcman->listeners, ChannelName);
690 if (!listener)
691 {
692 *res = ERROR_NOT_FOUND;
693 goto out;
694 }
695
696 channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
697 if (channel)
698 {
699 switch (channel->state)
700 {
701 case DVC_CHANNEL_RUNNING:
702 WLog_Print(drdynvc->log, WLOG_ERROR,
703 "Protocol error: Duplicated ChannelId %" PRIu32 " (%s)!", ChannelId,
704 ChannelName);
705 *res = CHANNEL_RC_ALREADY_OPEN;
706 goto out;
707
708 case DVC_CHANNEL_CLOSED:
709 case DVC_CHANNEL_INIT:
710 default:
711 {
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;
715 goto out;
716 }
717 }
718 }
719 else
720 {
721 if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
722 {
723 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_channel_new failed!");
724 *res = CHANNEL_RC_NO_MEMORY;
725 goto out;
726 }
727 }
728
729 if (!HashTable_Insert(dvcman->channelsById, &channel->channel_id, channel))
730 {
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);
734 channel = NULL;
735 goto out;
736 }
737
738 channel->iface.Write = dvcman_write_channel;
739 channel->iface.Close = dvcman_close_channel_iface;
740 bAccept = TRUE;
741
742 *res = listener->listener_callback->OnNewChannelConnection(
743 listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback);
744
745 if (*res != CHANNEL_RC_OK)
746 {
747 WLog_Print(drdynvc->log, WLOG_ERROR,
748 "OnNewChannelConnection failed with error %" PRIu32 "!", *res);
749 *res = ERROR_INTERNAL_ERROR;
750 dvcman_channel_unref(channel);
751 goto out;
752 }
753
754 if (!bAccept)
755 {
756 WLog_Print(drdynvc->log, WLOG_ERROR, "OnNewChannelConnection returned with bAccept FALSE!");
757 *res = ERROR_INTERNAL_ERROR;
758 dvcman_channel_unref(channel);
759 channel = NULL;
760 goto out;
761 }
762
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;
769
770 IFCALLRET(context->OnChannelConnected, *res, context, ChannelName, listener->iface.pInterface);
771 if (*res != CHANNEL_RC_OK)
772 {
773 WLog_Print(drdynvc->log, WLOG_ERROR,
774 "context.OnChannelConnected failed with error %" PRIu32 "", *res);
775 }
776
777out:
778 HashTable_Unlock(dvcman->listeners);
779
780 return channel;
781}
782
788static UINT dvcman_open_channel(drdynvcPlugin* drdynvc, DVCMAN_CHANNEL* channel)
789{
790 IWTSVirtualChannelCallback* pCallback = NULL;
791 UINT error = CHANNEL_RC_OK;
792
793 WINPR_ASSERT(drdynvc);
794 WINPR_ASSERT(channel);
795 if (channel->state == DVC_CHANNEL_RUNNING)
796 {
797 pCallback = channel->channel_callback;
798
799 if (pCallback->OnOpen)
800 {
801 check_open_close_receive(channel);
802 error = pCallback->OnOpen(pCallback);
803 if (error)
804 {
805 WLog_Print(drdynvc->log, WLOG_ERROR, "OnOpen failed with error %" PRIu32 "!",
806 error);
807 goto out;
808 }
809 }
810
811 WLog_Print(drdynvc->log, WLOG_DEBUG, "open_channel: ChannelId %" PRIu32 "",
812 channel->channel_id);
813 }
814
815out:
816 return error;
817}
818
824static UINT dvcman_receive_channel_data_first(DVCMAN_CHANNEL* channel, UINT32 length)
825{
826 WINPR_ASSERT(channel);
827 WINPR_ASSERT(channel->dvcman);
828 if (channel->dvc_data)
829 Stream_Release(channel->dvc_data);
830
831 channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
832
833 if (!channel->dvc_data)
834 {
835 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
836 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
837 return CHANNEL_RC_NO_MEMORY;
838 }
839
840 channel->dvc_data_length = length;
841 return CHANNEL_RC_OK;
842}
843
849static UINT dvcman_receive_channel_data(DVCMAN_CHANNEL* channel, wStream* data,
850 WINPR_ATTR_UNUSED UINT32 ThreadingFlags)
851{
852 UINT status = CHANNEL_RC_OK;
853 size_t dataSize = Stream_GetRemainingLength(data);
854
855 WINPR_ASSERT(channel);
856 WINPR_ASSERT(channel->dvcman);
857 if (channel->dvc_data)
858 {
859 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
860
861 /* Fragmented data */
862 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
863 {
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;
868 goto out;
869 }
870
871 Stream_Copy(data, channel->dvc_data, dataSize);
872
873 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
874 {
875 Stream_SealLength(channel->dvc_data);
876 Stream_SetPosition(channel->dvc_data, 0);
877
878 status = dvcman_call_on_receive(channel, channel->dvc_data);
879 Stream_Release(channel->dvc_data);
880 channel->dvc_data = NULL;
881 }
882 }
883 else
884 status = dvcman_call_on_receive(channel, data);
885
886out:
887 return status;
888}
889
890static UINT8 drdynvc_write_variable_uint(wStream* s, UINT32 val)
891{
892 UINT8 cb = 0;
893
894 if (val <= 0xFF)
895 {
896 cb = 0;
897 Stream_Write_UINT8(s, (UINT8)val);
898 }
899 else if (val <= 0xFFFF)
900 {
901 cb = 1;
902 Stream_Write_UINT16(s, (UINT16)val);
903 }
904 else
905 {
906 cb = 2;
907 Stream_Write_UINT32(s, val);
908 }
909
910 return cb;
911}
912
918static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s)
919{
920 UINT status = 0;
921
922 if (!drdynvc)
923 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
924 else
925 {
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);
930 }
931
932 switch (status)
933 {
934 case CHANNEL_RC_OK:
935 return CHANNEL_RC_OK;
936
937 case CHANNEL_RC_NOT_CONNECTED:
938 Stream_Release(s);
939 return CHANNEL_RC_OK;
940
941 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
942 Stream_Release(s);
943 WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
944 return status;
945
946 default:
947 Stream_Release(s);
948 WLog_Print(drdynvc->log, WLOG_ERROR,
949 "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
950 WTSErrorToString(status), status);
951 return status;
952 }
953}
954
960static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
961 UINT32 dataSize, BOOL* close)
962{
963 wStream* data_out = NULL;
964 size_t pos = 0;
965 UINT8 cbChId = 0;
966 UINT8 cbLen = 0;
967 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
968 DVCMAN* dvcman = NULL;
969
970 if (!drdynvc)
971 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
972
973 dvcman = (DVCMAN*)drdynvc->channel_mgr;
974 WINPR_ASSERT(dvcman);
975
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);
979
980 if (!data_out)
981 {
982 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
983 return CHANNEL_RC_NO_MEMORY;
984 }
985
986 Stream_SetPosition(data_out, 1);
987 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
988 pos = Stream_GetPosition(data_out);
989
990 if (dataSize == 0)
991 {
992 /* TODO: shall treat that case with write(0) that do a close */
993 *close = TRUE;
994 Stream_Release(data_out);
995 }
996 else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
997 {
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);
1003 }
1004 else
1005 {
1006 /* Fragment the data */
1007 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
1008 pos = Stream_GetPosition(data_out);
1009 Stream_SetPosition(data_out, 0);
1010
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);
1014
1015 {
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);
1020
1021 data += chunkLength;
1022 dataSize -= chunkLength;
1023 }
1024 status = drdynvc_send(drdynvc, data_out);
1025
1026 while (status == CHANNEL_RC_OK && dataSize > 0)
1027 {
1028 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
1029
1030 if (!data_out)
1031 {
1032 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1033 return CHANNEL_RC_NO_MEMORY;
1034 }
1035
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);
1042
1043 uint32_t chunkLength = dataSize;
1044
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);
1048
1049 Stream_Write(data_out, data, chunkLength);
1050 data += chunkLength;
1051 dataSize -= chunkLength;
1052 status = drdynvc_send(drdynvc, data_out);
1053 }
1054 }
1055
1056 if (status != CHANNEL_RC_OK)
1057 {
1058 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1059 WTSErrorToString(status), status);
1060 return status;
1061 }
1062
1063 return CHANNEL_RC_OK;
1064}
1065
1071static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
1072{
1073 UINT status = 0;
1074 wStream* s = NULL;
1075 DVCMAN* dvcman = NULL;
1076
1077 if (!drdynvc)
1078 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1079
1080 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1081 WINPR_ASSERT(dvcman);
1082
1083 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_response");
1084 s = StreamPool_Take(dvcman->pool, 4);
1085
1086 if (!s)
1087 {
1088 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_Ndrdynvc_write_variable_uintew failed!");
1089 return CHANNEL_RC_NO_MEMORY;
1090 }
1091
1092 Stream_Write_UINT16(s, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
1093 Stream_Write_UINT16(s, drdynvc->version);
1094 status = drdynvc_send(drdynvc, s);
1095
1096 if (status != CHANNEL_RC_OK)
1097 {
1098 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1099 WTSErrorToString(status), status);
1100 }
1101
1102 return status;
1103}
1104
1110static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId,
1111 wStream* s)
1112{
1113 UINT status = 0;
1114
1115 if (!drdynvc)
1116 return CHANNEL_RC_BAD_INIT_HANDLE;
1117
1118 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
1119 return ERROR_INVALID_DATA;
1120
1121 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_request Sp=%d cbChId=%d", Sp, cbChId);
1122 Stream_Seek(s, 1); /* pad */
1123 Stream_Read_UINT16(s, drdynvc->version);
1124
1125 /* RDP8 servers offer version 3, though Microsoft forgot to document it
1126 * in their early documents. It behaves the same as version 2.
1127 */
1128 if ((drdynvc->version == 2) || (drdynvc->version == 3))
1129 {
1130 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1131 return ERROR_INVALID_DATA;
1132
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);
1137 }
1138
1139 status = drdynvc_send_capability_response(drdynvc);
1140 drdynvc->state = DRDYNVC_STATE_READY;
1141 return status;
1142}
1143
1144static UINT32 drdynvc_cblen_to_bytes(int cbLen)
1145{
1146 switch (cbLen)
1147 {
1148 case 0:
1149 return 1;
1150
1151 case 1:
1152 return 2;
1153
1154 default:
1155 return 4;
1156 }
1157}
1158
1159static UINT32 drdynvc_read_variable_uint(wStream* s, int cbLen)
1160{
1161 UINT32 val = 0;
1162
1163 switch (cbLen)
1164 {
1165 case 0:
1166 Stream_Read_UINT8(s, val);
1167 break;
1168
1169 case 1:
1170 Stream_Read_UINT16(s, val);
1171 break;
1172
1173 default:
1174 Stream_Read_UINT32(s, val);
1175 break;
1176 }
1177
1178 return val;
1179}
1180
1186static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, UINT8 Sp, UINT8 cbChId,
1187 wStream* s)
1188{
1189 UINT status = 0;
1190 wStream* data_out = NULL;
1191 UINT channel_status = 0;
1192 DVCMAN* dvcman = NULL;
1193 DVCMAN_CHANNEL* channel = NULL;
1194 INT32 retStatus = 0;
1195
1196 WINPR_UNUSED(Sp);
1197 if (!drdynvc)
1198 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1199
1200 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1201 WINPR_ASSERT(dvcman);
1202
1203 if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1204 {
1210 drdynvc->version = 3;
1211
1212 if ((status = drdynvc_send_capability_response(drdynvc)))
1213 {
1214 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_send_capability_response failed!");
1215 return status;
1216 }
1217
1218 drdynvc->state = DRDYNVC_STATE_READY;
1219 }
1220
1221 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1222 return ERROR_INVALID_DATA;
1223
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);
1228
1229 if (strnlen(name, length) >= length)
1230 return ERROR_INVALID_DATA;
1231
1232 WLog_Print(drdynvc->log, WLOG_DEBUG,
1233 "process_create_request: ChannelId=%" PRIu32 " ChannelName=%s", ChannelId, name);
1234
1235 data_out = StreamPool_Take(dvcman->pool, pos + 4);
1236 if (!data_out)
1237 {
1238 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1239 return CHANNEL_RC_NO_MEMORY;
1240 }
1241
1242 Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1243 Stream_SetPosition(s, 1);
1244 Stream_Copy(s, data_out, pos - 1);
1245
1246 channel =
1247 dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name, &channel_status);
1248 switch (channel_status)
1249 {
1250 case CHANNEL_RC_OK:
1251 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel created");
1252 retStatus = 0;
1253 break;
1254 case CHANNEL_RC_NO_MEMORY:
1255 WLog_Print(drdynvc->log, WLOG_DEBUG, "not enough memory for channel creation");
1256 retStatus = STATUS_NO_MEMORY;
1257 break;
1258 case ERROR_NOT_FOUND:
1259 WLog_Print(drdynvc->log, WLOG_DEBUG, "no listener for '%s'", name);
1260 retStatus = STATUS_NOT_FOUND; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1261 break;
1262 default:
1263 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel creation error");
1264 retStatus = STATUS_UNSUCCESSFUL; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1265 break;
1266 }
1267 Stream_Write_INT32(data_out, retStatus);
1268
1269 status = drdynvc_send(drdynvc, data_out);
1270 if (status != CHANNEL_RC_OK)
1271 {
1272 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1273 WTSErrorToString(status), status);
1274 dvcman_channel_unref(channel);
1275 return status;
1276 }
1277
1278 if (channel_status == CHANNEL_RC_OK)
1279 {
1280 if ((status = dvcman_open_channel(drdynvc, channel)))
1281 {
1282 WLog_Print(drdynvc->log, WLOG_ERROR,
1283 "dvcman_open_channel failed with error %" PRIu32 "!", status);
1284 return status;
1285 }
1286 }
1287
1288 return status;
1289}
1290
1296static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1297 UINT32 ThreadingFlags)
1298{
1299 UINT status = CHANNEL_RC_OK;
1300 UINT32 Length = 0;
1301 UINT32 ChannelId = 0;
1302 DVCMAN_CHANNEL* channel = NULL;
1303
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;
1308
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);
1314
1315 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1316 if (!channel)
1317 {
1323 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
1324 return CHANNEL_RC_OK;
1325 }
1326
1327 if (channel->state != DVC_CHANNEL_RUNNING)
1328 goto out;
1329
1330 status = dvcman_receive_channel_data_first(channel, Length);
1331
1332 if (status == CHANNEL_RC_OK)
1333 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1334
1335 if (status != CHANNEL_RC_OK)
1336 status = dvcman_channel_close(channel, FALSE, FALSE);
1337
1338out:
1339 dvcman_channel_unref(channel);
1340 return status;
1341}
1342
1348static UINT drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1349 UINT32 ThreadingFlags)
1350{
1351 UINT32 ChannelId = 0;
1352 DVCMAN_CHANNEL* channel = NULL;
1353 UINT status = CHANNEL_RC_OK;
1354
1355 WINPR_ASSERT(drdynvc);
1356 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1357 return ERROR_INVALID_DATA;
1358
1359 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1360 WLog_Print(drdynvc->log, WLOG_TRACE, "process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp,
1361 cbChId, ChannelId);
1362
1363 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1364 if (!channel)
1365 {
1371 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
1372 return CHANNEL_RC_OK;
1373 }
1374
1375 if (channel->state != DVC_CHANNEL_RUNNING)
1376 goto out;
1377
1378 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1379 if (status != CHANNEL_RC_OK)
1380 status = dvcman_channel_close(channel, FALSE, FALSE);
1381
1382out:
1383 dvcman_channel_unref(channel);
1384 return status;
1385}
1386
1392static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1393{
1394 UINT32 ChannelId = 0;
1395 DVCMAN_CHANNEL* channel = NULL;
1396
1397 WINPR_ASSERT(drdynvc);
1398 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1399 return ERROR_INVALID_DATA;
1400
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,
1404 ChannelId);
1405
1406 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1407 if (!channel)
1408 {
1409 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_close_request channel %" PRIu32 " not present",
1410 ChannelId);
1411 return CHANNEL_RC_OK;
1412 }
1413
1414 dvcman_channel_close(channel, TRUE, FALSE);
1415 dvcman_channel_unref(channel);
1416 return CHANNEL_RC_OK;
1417}
1418
1424static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc, wStream* s, UINT32 ThreadingFlags)
1425{
1426 UINT8 value = 0;
1427
1428 WINPR_ASSERT(drdynvc);
1429 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1430 return ERROR_INVALID_DATA;
1431
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);
1438
1439 switch (Cmd)
1440 {
1441 case CAPABILITY_REQUEST_PDU:
1442 return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1443
1444 case CREATE_REQUEST_PDU:
1445 return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1446
1447 case DATA_FIRST_PDU:
1448 return drdynvc_process_data_first(drdynvc, Sp, cbChId, s, ThreadingFlags);
1449
1450 case DATA_PDU:
1451 return drdynvc_process_data(drdynvc, Sp, cbChId, s, ThreadingFlags);
1452
1453 case CLOSE_REQUEST_PDU:
1454 return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1455
1456 default:
1457 WLog_Print(drdynvc->log, WLOG_ERROR, "unknown drdynvc cmd 0x%x", Cmd);
1458 return ERROR_INTERNAL_ERROR;
1459 }
1460}
1461
1467static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc, void* pData,
1468 UINT32 dataLength, UINT32 totalLength,
1469 UINT32 dataFlags)
1470{
1471 wStream* data_in = NULL;
1472
1473 WINPR_ASSERT(drdynvc);
1474 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1475 {
1476 return CHANNEL_RC_OK;
1477 }
1478
1479 if (dataFlags & CHANNEL_FLAG_FIRST)
1480 {
1481 DVCMAN* mgr = (DVCMAN*)drdynvc->channel_mgr;
1482 if (drdynvc->data_in)
1483 Stream_Release(drdynvc->data_in);
1484
1485 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1486 }
1487
1488 if (!(data_in = drdynvc->data_in))
1489 {
1490 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1491 return CHANNEL_RC_NO_MEMORY;
1492 }
1493
1494 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1495 {
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;
1500 }
1501
1502 Stream_Write(data_in, pData, dataLength);
1503
1504 if (dataFlags & CHANNEL_FLAG_LAST)
1505 {
1506 const size_t cap = Stream_Capacity(data_in);
1507 const size_t pos = Stream_GetPosition(data_in);
1508 if (cap < pos)
1509 {
1510 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_plugin_process_received: read error");
1511 return ERROR_INVALID_DATA;
1512 }
1513
1514 drdynvc->data_in = NULL;
1515 Stream_SealLength(data_in);
1516 Stream_SetPosition(data_in, 0);
1517
1518 if (drdynvc->async)
1519 {
1520 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (void*)data_in, NULL))
1521 {
1522 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Post failed!");
1523 return ERROR_INTERNAL_ERROR;
1524 }
1525 }
1526 else
1527 {
1528 UINT error = drdynvc_order_recv(drdynvc, data_in, TRUE);
1529 Stream_Release(data_in);
1530
1531 if (error)
1532 {
1533 WLog_Print(drdynvc->log, WLOG_WARN,
1534 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1535 }
1536 }
1537 }
1538
1539 return CHANNEL_RC_OK;
1540}
1541
1542static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1543 UINT event, LPVOID pData,
1544 UINT32 dataLength, UINT32 totalLength,
1545 UINT32 dataFlags)
1546{
1547 UINT error = CHANNEL_RC_OK;
1548 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1549
1550 WINPR_ASSERT(drdynvc);
1551 switch (event)
1552 {
1553 case CHANNEL_EVENT_DATA_RECEIVED:
1554 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1555 {
1556 WLog_ERR(TAG, "drdynvc_virtual_channel_open_event: error no match");
1557 return;
1558 }
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
1563 "",
1564 error);
1565
1566 break;
1567
1568 case CHANNEL_EVENT_WRITE_CANCELLED:
1569 case CHANNEL_EVENT_WRITE_COMPLETE:
1570 {
1571 wStream* s = (wStream*)pData;
1572 Stream_Release(s);
1573 }
1574 break;
1575
1576 case CHANNEL_EVENT_USER:
1577 break;
1578 default:
1579 break;
1580 }
1581
1582 if (error && drdynvc && drdynvc->rdpcontext)
1583 setChannelError(drdynvc->rdpcontext, error,
1584 "drdynvc_virtual_channel_open_event reported an error");
1585}
1586
1587static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1588{
1589 /* TODO: rewrite this */
1590 wStream* data = NULL;
1591 wMessage message = { 0 };
1592 UINT error = CHANNEL_RC_OK;
1593 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1594
1595 if (!drdynvc)
1596 {
1597 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1598 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1599 }
1600
1601 while (1)
1602 {
1603 if (!MessageQueue_Wait(drdynvc->queue))
1604 {
1605 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Wait failed!");
1606 error = ERROR_INTERNAL_ERROR;
1607 break;
1608 }
1609
1610 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1611 {
1612 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Peek failed!");
1613 error = ERROR_INTERNAL_ERROR;
1614 break;
1615 }
1616
1617 if (message.id == WMQ_QUIT)
1618 break;
1619
1620 if (message.id == 0)
1621 {
1622 UINT32 ThreadingFlags = TRUE;
1623 data = (wStream*)message.wParam;
1624
1625 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1626 {
1627 WLog_Print(drdynvc->log, WLOG_WARN,
1628 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1629 }
1630
1631 Stream_Release(data);
1632 }
1633 }
1634
1635 {
1636 /* Disconnect remaining dynamic channels that the server did not.
1637 * This is required to properly shut down channels by calling the appropriate
1638 * event handlers. */
1639 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1640
1641 HashTable_Clear(drdynvcMgr->channelsById);
1642 }
1643
1644 if (error && drdynvc->rdpcontext)
1645 setChannelError(drdynvc->rdpcontext, error,
1646 "drdynvc_virtual_channel_client_thread reported an error");
1647
1648 ExitThread((DWORD)error);
1649 return error;
1650}
1651
1652static void drdynvc_queue_object_free(void* obj)
1653{
1654 wStream* s = NULL;
1655 wMessage* msg = (wMessage*)obj;
1656
1657 if (!msg || (msg->id != 0))
1658 return;
1659
1660 s = (wStream*)msg->wParam;
1661
1662 if (s)
1663 Stream_Release(s);
1664}
1665
1666static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1667 UINT32 dataLength)
1668{
1669 wObject* obj = NULL;
1670 WINPR_UNUSED(pData);
1671 WINPR_UNUSED(dataLength);
1672
1673 if (!drdynvc)
1674 goto error;
1675
1676 drdynvc->queue = MessageQueue_New(NULL);
1677
1678 if (!drdynvc->queue)
1679 {
1680 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_New failed!");
1681 goto error;
1682 }
1683
1684 obj = MessageQueue_Object(drdynvc->queue);
1685 obj->fnObjectFree = drdynvc_queue_object_free;
1686 drdynvc->channel_mgr = dvcman_new(drdynvc);
1687
1688 if (!drdynvc->channel_mgr)
1689 {
1690 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_new failed!");
1691 goto error;
1692 }
1693
1694 return CHANNEL_RC_OK;
1695error:
1696 return ERROR_INTERNAL_ERROR;
1697}
1698
1704static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1705 UINT32 dataLength)
1706{
1707 UINT error = 0;
1708 UINT32 status = 0;
1709 rdpSettings* settings = NULL;
1710
1711 WINPR_ASSERT(drdynvc);
1712 WINPR_UNUSED(pData);
1713 WINPR_UNUSED(dataLength);
1714
1715 if (!drdynvc)
1716 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1717
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);
1722
1723 if (status != CHANNEL_RC_OK)
1724 {
1725 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelOpen failed with %s [%08" PRIX32 "]",
1726 WTSErrorToString(status), status);
1727 return status;
1728 }
1729
1730 WINPR_ASSERT(drdynvc->rdpcontext);
1731 settings = drdynvc->rdpcontext->settings;
1732 WINPR_ASSERT(settings);
1733
1734 for (UINT32 index = 0;
1735 index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
1736 {
1737 const ADDIN_ARGV* args =
1738 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1739 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1740
1741 if (CHANNEL_RC_OK != error)
1742 goto error;
1743 }
1744
1745 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1746 {
1747 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_init failed with error %" PRIu32 "!", error);
1748 goto error;
1749 }
1750
1751 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1752
1753 if (drdynvc->async)
1754 {
1755 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1756 (void*)drdynvc, 0, NULL)))
1757 {
1758 error = ERROR_INTERNAL_ERROR;
1759 WLog_Print(drdynvc->log, WLOG_ERROR, "CreateThread failed!");
1760 goto error;
1761 }
1762
1763 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1764 WLog_Print(drdynvc->log, WLOG_WARN, "SetThreadPriority failed, ignoring.");
1765 }
1766
1767error:
1768 return error;
1769}
1770
1776static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1777{
1778 UINT status = 0;
1779
1780 if (!drdynvc)
1781 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1782
1783 if (drdynvc->OpenHandle == 0)
1784 return CHANNEL_RC_OK;
1785
1786 if (drdynvc->queue)
1787 {
1788 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1789 {
1790 status = GetLastError();
1791 WLog_Print(drdynvc->log, WLOG_ERROR,
1792 "MessageQueue_PostQuit failed with error %" PRIu32 "", status);
1793 return status;
1794 }
1795 }
1796
1797 if (drdynvc->thread)
1798 {
1799 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1800 {
1801 status = GetLastError();
1802 WLog_Print(drdynvc->log, WLOG_ERROR,
1803 "WaitForSingleObject failed with error %" PRIu32 "", status);
1804 return status;
1805 }
1806
1807 (void)CloseHandle(drdynvc->thread);
1808 drdynvc->thread = NULL;
1809 }
1810 else
1811 {
1812 {
1813 /* Disconnect remaining dynamic channels that the server did not.
1814 * This is required to properly shut down channels by calling the appropriate
1815 * event handlers. */
1816 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1817
1818 HashTable_Clear(drdynvcMgr->channelsById);
1819 }
1820 }
1821
1822 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1823 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1824 drdynvc->OpenHandle);
1825
1826 if (status != CHANNEL_RC_OK)
1827 {
1828 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1829 WTSErrorToString(status), status);
1830 }
1831
1832 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1833 if (drdynvc->queue)
1834 MessageQueue_Clear(drdynvc->queue);
1835 drdynvc->OpenHandle = 0;
1836
1837 if (drdynvc->data_in)
1838 {
1839 Stream_Release(drdynvc->data_in);
1840 drdynvc->data_in = NULL;
1841 }
1842
1843 return status;
1844}
1845
1851static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1852{
1853 if (!drdynvc)
1854 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1855
1856 MessageQueue_Free(drdynvc->queue);
1857 drdynvc->queue = NULL;
1858
1859 if (drdynvc->channel_mgr)
1860 {
1861 dvcman_free(drdynvc, drdynvc->channel_mgr);
1862 drdynvc->channel_mgr = NULL;
1863 }
1864 drdynvc->InitHandle = 0;
1865 free(drdynvc->context);
1866 free(drdynvc);
1867 return CHANNEL_RC_OK;
1868}
1869
1870static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1871{
1872 UINT error = CHANNEL_RC_OK;
1873 DVCMAN* dvcman = NULL;
1874
1875 if (!drdynvc)
1876 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1877
1878 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1879
1880 if (!dvcman)
1881 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1882
1883 ArrayList_Lock(dvcman->plugins);
1884 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1885 {
1886 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1887
1888 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1889 if (error != CHANNEL_RC_OK)
1890 {
1891 WLog_Print(drdynvc->log, WLOG_ERROR, "Attach failed with error %" PRIu32 "!", error);
1892 goto fail;
1893 }
1894 }
1895
1896fail:
1897 ArrayList_Unlock(dvcman->plugins);
1898 return error;
1899}
1900
1901static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1902{
1903 UINT error = CHANNEL_RC_OK;
1904 DVCMAN* dvcman = NULL;
1905
1906 if (!drdynvc)
1907 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1908
1909 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1910
1911 if (!dvcman)
1912 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1913
1914 ArrayList_Lock(dvcman->plugins);
1915 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1916 {
1917 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1918
1919 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1920 if (error != CHANNEL_RC_OK)
1921 {
1922 WLog_Print(drdynvc->log, WLOG_ERROR, "Detach failed with error %" PRIu32 "!", error);
1923 goto fail;
1924 }
1925 }
1926
1927fail:
1928 ArrayList_Unlock(dvcman->plugins);
1929
1930 return error;
1931}
1932
1933static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1934 UINT event, LPVOID pData,
1935 UINT dataLength)
1936{
1937 UINT error = CHANNEL_RC_OK;
1938 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1939
1940 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
1941 {
1942 WLog_ERR(TAG, "drdynvc_virtual_channel_init_event: error no match");
1943 return;
1944 }
1945
1946 switch (event)
1947 {
1948 case CHANNEL_EVENT_INITIALIZED:
1949 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
1950 break;
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 "",
1955 error);
1956
1957 break;
1958
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
1963 "",
1964 error);
1965
1966 break;
1967
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 "",
1972 error);
1973
1974 break;
1975
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 "",
1980 error);
1981
1982 break;
1983
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 "",
1988 error);
1989
1990 break;
1991
1992 default:
1993 break;
1994 }
1995
1996 if (error && drdynvc->rdpcontext)
1997 setChannelError(drdynvc->rdpcontext, error,
1998 "drdynvc_virtual_channel_init_event_ex reported an error");
1999}
2000
2005static int drdynvc_get_version(DrdynvcClientContext* context)
2006{
2007 WINPR_ASSERT(context);
2008 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
2009 WINPR_ASSERT(drdynvc);
2010 return drdynvc->version;
2011}
2012
2013/* drdynvc is always built-in */
2014#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
2015
2016FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2017 PVOID pInitHandle))
2018{
2019 UINT rc = 0;
2020 drdynvcPlugin* drdynvc = NULL;
2021 DrdynvcClientContext* context = NULL;
2022 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = NULL;
2023 drdynvc = (drdynvcPlugin*)calloc(1, sizeof(drdynvcPlugin));
2024
2025 WINPR_ASSERT(pEntryPoints);
2026 if (!drdynvc)
2027 {
2028 WLog_ERR(TAG, "calloc failed!");
2029 return FALSE;
2030 }
2031
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;
2037 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2038
2039 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2040 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2041 {
2042 context = (DrdynvcClientContext*)calloc(1, sizeof(DrdynvcClientContext));
2043
2044 if (!context)
2045 {
2046 WLog_Print(drdynvc->log, WLOG_ERROR, "calloc failed!");
2047 free(drdynvc);
2048 return FALSE;
2049 }
2050
2051 context->handle = (void*)drdynvc;
2052 context->custom = NULL;
2053 drdynvc->context = context;
2054 context->GetVersion = drdynvc_get_version;
2055 drdynvc->rdpcontext = pEntryPointsEx->context;
2056 if (!freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2057 FreeRDP_TransportDumpReplay) &&
2058 !freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2059 FreeRDP_SynchronousDynamicChannels))
2060 drdynvc->async = TRUE;
2061 }
2062
2063 drdynvc->log = WLog_Get(TAG);
2064 WLog_Print(drdynvc->log, WLOG_DEBUG, "VirtualChannelEntryEx");
2065 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2067 drdynvc->InitHandle = pInitHandle;
2068
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);
2073
2074 if (CHANNEL_RC_OK != rc)
2075 {
2076 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
2077 WTSErrorToString(rc), rc);
2078 free(drdynvc->context);
2079 free(drdynvc);
2080 return FALSE;
2081 }
2082
2083 drdynvc->channelEntryPoints.pInterface = context;
2084 return TRUE;
2085}
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.
Definition svc.h:60
This struct contains function pointer to initialize/free objects.
Definition collections.h:57