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#include <freerdp/codec/zgfx.h>
33
34#include "drdynvc_main.h"
35
36#define TAG CHANNELS_TAG("drdynvc.client")
37
38static const char* channel_state2str(DVC_CHANNEL_STATE state)
39{
40 switch (state)
41 {
42 case DVC_CHANNEL_INIT:
43 return "DVC_CHANNEL_INIT";
44 case DVC_CHANNEL_RUNNING:
45 return "DVC_CHANNEL_RUNNING";
46 case DVC_CHANNEL_CLOSED:
47 return "DVC_CHANNEL_CLOSED";
48 default:
49 return "DVC_CHANNEL_UNKNOWN";
50 }
51}
52
53static void dvcman_channel_free(DVCMAN_CHANNEL* channel);
54static UINT dvcman_channel_close(DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn);
55static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr);
56static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
57 UINT32 dataSize, BOOL* close);
58static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s);
59
60static void dvcman_wtslistener_free(DVCMAN_LISTENER* listener)
61{
62 if (listener)
63 free(listener->channel_name);
64 free(listener);
65}
66
72static UINT dvcman_get_configuration(IWTSListener* pListener, void** ppPropertyBag)
73{
74 WINPR_ASSERT(ppPropertyBag);
75 WINPR_UNUSED(pListener);
76 *ppPropertyBag = NULL;
77 return ERROR_INTERNAL_ERROR;
78}
79
85static UINT dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
86 const char* pszChannelName, ULONG ulFlags,
87 IWTSListenerCallback* pListenerCallback,
88 IWTSListener** ppListener)
89{
90 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
91 DVCMAN_LISTENER* listener = NULL;
92
93 WINPR_ASSERT(dvcman);
94 WLog_DBG(TAG, "create_listener: %" PRIuz ".%s.", HashTable_Count(dvcman->listeners) + 1,
95 pszChannelName);
96 listener = (DVCMAN_LISTENER*)calloc(1, sizeof(DVCMAN_LISTENER));
97
98 if (!listener)
99 {
100 WLog_ERR(TAG, "calloc failed!");
101 return CHANNEL_RC_NO_MEMORY;
102 }
103
104 listener->iface.GetConfiguration = dvcman_get_configuration;
105 listener->iface.pInterface = NULL;
106 listener->dvcman = dvcman;
107 listener->channel_name = _strdup(pszChannelName);
108
109 if (!listener->channel_name)
110 {
111 WLog_ERR(TAG, "_strdup failed!");
112 dvcman_wtslistener_free(listener);
113 return CHANNEL_RC_NO_MEMORY;
114 }
115
116 listener->flags = ulFlags;
117 listener->listener_callback = pListenerCallback;
118
119 if (ppListener)
120 *ppListener = (IWTSListener*)listener;
121
122 if (!HashTable_Insert(dvcman->listeners, listener->channel_name, listener))
123 {
124 dvcman_wtslistener_free(listener);
125 return ERROR_INTERNAL_ERROR;
126 }
127
128 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert takes ownership of listener
129 return CHANNEL_RC_OK;
130}
131
132static UINT dvcman_destroy_listener(IWTSVirtualChannelManager* pChannelMgr, IWTSListener* pListener)
133{
134 DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)pListener;
135
136 WINPR_UNUSED(pChannelMgr);
137
138 if (listener)
139 {
140 DVCMAN* dvcman = listener->dvcman;
141 if (dvcman)
142 HashTable_Remove(dvcman->listeners, listener->channel_name);
143 }
144
145 return CHANNEL_RC_OK;
146}
147
153static UINT dvcman_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name,
154 IWTSPlugin* pPlugin)
155{
156 WINPR_ASSERT(pEntryPoints);
157 DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
158
159 WINPR_ASSERT(dvcman);
160 if (!ArrayList_Append(dvcman->plugin_names, name))
161 return ERROR_INTERNAL_ERROR;
162 if (!ArrayList_Append(dvcman->plugins, pPlugin))
163 return ERROR_INTERNAL_ERROR;
164
165 WLog_DBG(TAG, "register_plugin: num_plugins %" PRIuz, ArrayList_Count(dvcman->plugins));
166 return CHANNEL_RC_OK;
167}
168
169static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name)
170{
171 IWTSPlugin* plugin = NULL;
172 size_t nc = 0;
173 size_t pc = 0;
174 WINPR_ASSERT(pEntryPoints);
175 DVCMAN* dvcman = ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->dvcman;
176 if (!dvcman || !pEntryPoints || !name)
177 return NULL;
178
179 nc = ArrayList_Count(dvcman->plugin_names);
180 pc = ArrayList_Count(dvcman->plugins);
181 if (nc != pc)
182 return NULL;
183
184 ArrayList_Lock(dvcman->plugin_names);
185 ArrayList_Lock(dvcman->plugins);
186 for (size_t i = 0; i < pc; i++)
187 {
188 const char* cur = ArrayList_GetItem(dvcman->plugin_names, i);
189 if (strcmp(cur, name) == 0)
190 {
191 plugin = ArrayList_GetItem(dvcman->plugins, i);
192 break;
193 }
194 }
195 ArrayList_Unlock(dvcman->plugin_names);
196 ArrayList_Unlock(dvcman->plugins);
197 return plugin;
198}
199
200static const ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
201{
202 WINPR_ASSERT(pEntryPoints);
203 return ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->args;
204}
205
206static rdpContext* dvcman_get_rdp_context(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
207{
208 DVCMAN_ENTRY_POINTS* entry = (DVCMAN_ENTRY_POINTS*)pEntryPoints;
209 WINPR_ASSERT(entry);
210 return entry->context;
211}
212
213static rdpSettings* dvcman_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
214{
215 rdpContext* context = dvcman_get_rdp_context(pEntryPoints);
216 WINPR_ASSERT(context);
217
218 return context->settings;
219}
220
221static UINT32 dvcman_get_channel_id(IWTSVirtualChannel* channel)
222{
223 DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
224 WINPR_ASSERT(dvc);
225 return dvc->channel_id;
226}
227
228static const char* dvcman_get_channel_name(IWTSVirtualChannel* channel)
229{
230 DVCMAN_CHANNEL* dvc = (DVCMAN_CHANNEL*)channel;
231 WINPR_ASSERT(dvc);
232 return dvc->channel_name;
233}
234
235static DVCMAN_CHANNEL* dvcman_get_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
236 UINT32 ChannelId, BOOL doRef)
237{
238 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
239 DVCMAN_CHANNEL* dvcChannel = NULL;
240
241 WINPR_ASSERT(dvcman);
242 HashTable_Lock(dvcman->channelsById);
243 dvcChannel = HashTable_GetItemValue(dvcman->channelsById, &ChannelId);
244 if (dvcChannel)
245 {
246 if (doRef)
247 InterlockedIncrement(&dvcChannel->refCounter);
248 }
249
250 HashTable_Unlock(dvcman->channelsById);
251 return dvcChannel;
252}
253
254static IWTSVirtualChannel* dvcman_find_channel_by_id(IWTSVirtualChannelManager* pChannelMgr,
255 UINT32 ChannelId)
256{
257 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
258 if (!channel)
259 return NULL;
260
261 return &channel->iface;
262}
263
264static void dvcman_plugin_terminate(void* plugin)
265{
266 IWTSPlugin* pPlugin = plugin;
267
268 WINPR_ASSERT(pPlugin);
269 UINT error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Terminated, pPlugin);
270 if (error != CHANNEL_RC_OK)
271 WLog_ERR(TAG, "Terminated failed with error %" PRIu32 "!", error);
272}
273
274static void wts_listener_free(void* arg)
275{
276 DVCMAN_LISTENER* listener = (DVCMAN_LISTENER*)arg;
277 dvcman_wtslistener_free(listener);
278}
279
280static BOOL channelIdMatch(const void* k1, const void* k2)
281{
282 WINPR_ASSERT(k1);
283 WINPR_ASSERT(k2);
284 return *((const UINT32*)k1) == *((const UINT32*)k2);
285}
286
287static UINT32 channelIdHash(const void* id)
288{
289 WINPR_ASSERT(id);
290 return *((const UINT32*)id);
291}
292
293static void channelByIdCleanerFn(void* value)
294{
295 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)value;
296 if (channel)
297 {
298 dvcman_channel_close(channel, FALSE, TRUE);
299 dvcman_channel_free(channel);
300 }
301}
302
303static IWTSVirtualChannelManager* dvcman_new(drdynvcPlugin* plugin)
304{
305 wObject* obj = NULL;
306 DVCMAN* dvcman = (DVCMAN*)calloc(1, sizeof(DVCMAN));
307
308 if (!dvcman)
309 return NULL;
310
311 dvcman->iface.CreateListener = dvcman_create_listener;
312 dvcman->iface.DestroyListener = dvcman_destroy_listener;
313 dvcman->iface.FindChannelById = dvcman_find_channel_by_id;
314 dvcman->iface.GetChannelId = dvcman_get_channel_id;
315 dvcman->iface.GetChannelName = dvcman_get_channel_name;
316 dvcman->drdynvc = plugin;
317 dvcman->channelsById = HashTable_New(TRUE);
318
319 if (!dvcman->channelsById)
320 goto fail;
321
322 HashTable_SetHashFunction(dvcman->channelsById, channelIdHash);
323 obj = HashTable_KeyObject(dvcman->channelsById);
324 WINPR_ASSERT(obj);
325 obj->fnObjectEquals = channelIdMatch;
326
327 obj = HashTable_ValueObject(dvcman->channelsById);
328 WINPR_ASSERT(obj);
329 obj->fnObjectFree = channelByIdCleanerFn;
330
331 dvcman->pool = StreamPool_New(TRUE, 10);
332 if (!dvcman->pool)
333 goto fail;
334
335 dvcman->listeners = HashTable_New(TRUE);
336 if (!dvcman->listeners)
337 goto fail;
338 HashTable_SetHashFunction(dvcman->listeners, HashTable_StringHash);
339
340 obj = HashTable_KeyObject(dvcman->listeners);
341 obj->fnObjectEquals = HashTable_StringCompare;
342
343 obj = HashTable_ValueObject(dvcman->listeners);
344 obj->fnObjectFree = wts_listener_free;
345
346 dvcman->plugin_names = ArrayList_New(TRUE);
347 if (!dvcman->plugin_names)
348 goto fail;
349 obj = ArrayList_Object(dvcman->plugin_names);
350 obj->fnObjectNew = winpr_ObjectStringClone;
351 obj->fnObjectFree = winpr_ObjectStringFree;
352
353 dvcman->plugins = ArrayList_New(TRUE);
354 if (!dvcman->plugins)
355 goto fail;
356 obj = ArrayList_Object(dvcman->plugins);
357 obj->fnObjectFree = dvcman_plugin_terminate;
358 return &dvcman->iface;
359fail:
360 dvcman_free(plugin, &dvcman->iface);
361 return NULL;
362}
363
369static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
370 const ADDIN_ARGV* args, rdpContext* context)
371{
372 WINPR_ASSERT(drdynvc);
373 WINPR_ASSERT(pChannelMgr);
374 WINPR_ASSERT(args);
375 WINPR_ASSERT(context);
376
377 WLog_Print(drdynvc->log, WLOG_INFO, "Loading Dynamic Virtual Channel %s", args->argv[0]);
378
379 PVIRTUALCHANNELENTRY pvce =
380 freerdp_load_channel_addin_entry(args->argv[0], NULL, NULL, FREERDP_ADDIN_CHANNEL_DYNAMIC);
381 PDVC_PLUGIN_ENTRY pDVCPluginEntry = WINPR_FUNC_PTR_CAST(pvce, PDVC_PLUGIN_ENTRY);
382
383 if (pDVCPluginEntry)
384 {
385 DVCMAN_ENTRY_POINTS entryPoints = { 0 };
386
387 entryPoints.iface.RegisterPlugin = dvcman_register_plugin;
388 entryPoints.iface.GetPlugin = dvcman_get_plugin;
389 entryPoints.iface.GetPluginData = dvcman_get_plugin_data;
390 entryPoints.iface.GetRdpSettings = dvcman_get_rdp_settings;
391 entryPoints.iface.GetRdpContext = dvcman_get_rdp_context;
392 entryPoints.dvcman = (DVCMAN*)pChannelMgr;
393 entryPoints.args = args;
394 entryPoints.context = context;
395 return pDVCPluginEntry(&entryPoints.iface);
396 }
397
398 return ERROR_INVALID_FUNCTION;
399}
400
401static void dvcman_channel_free(DVCMAN_CHANNEL* channel)
402{
403 if (!channel)
404 return;
405
406 if (channel->dvc_data)
407 Stream_Release(channel->dvc_data);
408
409 zgfx_context_free(channel->decompressor);
410 DeleteCriticalSection(&(channel->lock));
411 free(channel->channel_name);
412 free(channel);
413}
414
415static void dvcman_channel_unref(DVCMAN_CHANNEL* channel)
416{
417 WINPR_ASSERT(channel);
418 if (InterlockedDecrement(&channel->refCounter))
419 return;
420
421 DVCMAN* dvcman = channel->dvcman;
422 if (dvcman)
423 HashTable_Remove(dvcman->channelsById, &channel->channel_id);
424}
425
426static UINT dvcchannel_send_close(DVCMAN_CHANNEL* channel)
427{
428 WINPR_ASSERT(channel);
429 DVCMAN* dvcman = channel->dvcman;
430 drdynvcPlugin* drdynvc = dvcman->drdynvc;
431 wStream* s = StreamPool_Take(dvcman->pool, 5);
432
433 if (!s)
434 {
435 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
436 return CHANNEL_RC_NO_MEMORY;
437 }
438
439 Stream_Write_UINT8(s, (CLOSE_REQUEST_PDU << 4) | 0x02);
440 Stream_Write_UINT32(s, channel->channel_id);
441 return drdynvc_send(drdynvc, s);
442}
443
444static void check_open_close_receive(DVCMAN_CHANNEL* channel)
445{
446 WINPR_ASSERT(channel);
447
448 IWTSVirtualChannelCallback* cb = channel->channel_callback;
449 const char* name = channel->channel_name;
450 const UINT32 id = channel->channel_id;
451
452 WINPR_ASSERT(cb);
453 if (!cb->OnOpen || !cb->OnClose || !cb->OnDataReceived)
454 WLog_VRB(TAG, "{%s:%" PRIu32 "} OnOpen=%p, OnClose=%p, OnDataReceived=%p", name, id,
455 cb->OnOpen, cb->OnClose, cb->OnDataReceived);
456}
457
458static UINT dvcman_call_on_receive(DVCMAN_CHANNEL* channel, wStream* data)
459{
460 WINPR_ASSERT(channel);
461 WINPR_ASSERT(data);
462
463 IWTSVirtualChannelCallback* cb = channel->channel_callback;
464 WINPR_ASSERT(cb);
465
466 check_open_close_receive(channel);
467 WINPR_ASSERT(cb->OnDataReceived);
468 return cb->OnDataReceived(cb, data);
469}
470
471static UINT dvcman_channel_close(DVCMAN_CHANNEL* channel, BOOL perRequest, BOOL fromHashTableFn)
472{
473 UINT error = CHANNEL_RC_OK;
474 DrdynvcClientContext* context = NULL;
475
476 WINPR_ASSERT(channel);
477 switch (channel->state)
478 {
479 case DVC_CHANNEL_INIT:
480 break;
481 case DVC_CHANNEL_RUNNING:
482 if (channel->dvcman)
483 {
484 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
485 WINPR_ASSERT(drdynvc);
486 context = drdynvc->context;
487 if (perRequest)
488 WLog_Print(drdynvc->log, WLOG_DEBUG, "sending close confirm for '%s'",
489 channel->channel_name);
490
491 error = dvcchannel_send_close(channel);
492 if (error != CHANNEL_RC_OK)
493 {
494 if (perRequest)
495 WLog_Print(drdynvc->log, WLOG_DEBUG,
496 "error when sending closeRequest for '%s'",
497 channel->channel_name);
498 else
499 WLog_Print(drdynvc->log, WLOG_DEBUG,
500 "error when sending close confirm for '%s'",
501 channel->channel_name);
502 }
503 WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s destroyed channel %" PRIu32 "",
504 channel->channel_name, channel->channel_id);
505 }
506
507 channel->state = DVC_CHANNEL_CLOSED;
508
509 IWTSVirtualChannelCallback* cb = channel->channel_callback;
510 if (cb)
511 {
512 check_open_close_receive(channel);
513 IFCALL(cb->OnClose, cb);
514 }
515
516 channel->channel_callback = NULL;
517
518 if (channel->dvcman && channel->dvcman->drdynvc)
519 {
520 if (context)
521 {
522 IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
523 channel->pInterface);
524 }
525 }
526
527 if (!fromHashTableFn)
528 dvcman_channel_unref(channel);
529 break;
530 case DVC_CHANNEL_CLOSED:
531 break;
532 default:
533 break;
534 }
535
536 return error;
537}
538
539static DVCMAN_CHANNEL* dvcman_channel_new(WINPR_ATTR_UNUSED drdynvcPlugin* drdynvc,
540 IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
541 const char* ChannelName)
542{
543 DVCMAN_CHANNEL* channel = NULL;
544
545 WINPR_ASSERT(drdynvc);
546 WINPR_ASSERT(pChannelMgr);
547 channel = (DVCMAN_CHANNEL*)calloc(1, sizeof(DVCMAN_CHANNEL));
548
549 if (!channel)
550 return NULL;
551
552 channel->dvcman = (DVCMAN*)pChannelMgr;
553 channel->channel_id = ChannelId;
554 channel->refCounter = 1;
555 channel->state = DVC_CHANNEL_INIT;
556 channel->channel_name = _strdup(ChannelName);
557 if (!channel->channel_name)
558 goto fail;
559
560 channel->decompressor = zgfx_context_new(FALSE);
561 if (!channel->decompressor)
562 goto fail;
563
564 if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
565 goto fail;
566
567 return channel;
568fail:
569 dvcman_channel_free(channel);
570 return NULL;
571}
572
573static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
574{
575 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
576
577 WINPR_ASSERT(dvcman);
578 WINPR_UNUSED(drdynvc);
579
580 HashTable_Clear(dvcman->channelsById);
581 ArrayList_Clear(dvcman->plugins);
582 ArrayList_Clear(dvcman->plugin_names);
583 HashTable_Clear(dvcman->listeners);
584}
585static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
586{
587 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
588
589 WINPR_ASSERT(dvcman);
590 WINPR_UNUSED(drdynvc);
591
592 HashTable_Free(dvcman->channelsById);
593 ArrayList_Free(dvcman->plugins);
594 ArrayList_Free(dvcman->plugin_names);
595 HashTable_Free(dvcman->listeners);
596
597 StreamPool_Free(dvcman->pool);
598 free(dvcman);
599}
600
606static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
607{
608 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
609 UINT error = CHANNEL_RC_OK;
610
611 WINPR_ASSERT(dvcman);
612 ArrayList_Lock(dvcman->plugins);
613 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
614 {
615 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
616
617 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
618 if (error != CHANNEL_RC_OK)
619 {
620 WLog_Print(drdynvc->log, WLOG_ERROR, "Initialize failed with error %" PRIu32 "!",
621 error);
622 goto fail;
623 }
624 }
625
626fail:
627 ArrayList_Unlock(dvcman->plugins);
628 return error;
629}
630
636static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize, const BYTE* pBuffer,
637 void* pReserved)
638{
639 BOOL close = FALSE;
640 UINT status = 0;
641 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
642
643 WINPR_UNUSED(pReserved);
644 if (!channel || !channel->dvcman)
645 return CHANNEL_RC_BAD_CHANNEL;
646
647 EnterCriticalSection(&(channel->lock));
648 status =
649 drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize, &close);
650 LeaveCriticalSection(&(channel->lock));
651 /* Close delayed, it removes the channel struct */
652 if (close)
653 dvcman_channel_close(channel, FALSE, FALSE);
654
655 return status;
656}
657
663static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
664{
665 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
666
667 if (!channel)
668 return CHANNEL_RC_BAD_CHANNEL;
669
670 WLog_DBG(TAG, "close_channel_iface: id=%" PRIu32 "", channel->channel_id);
671 return dvcman_channel_close(channel, FALSE, FALSE);
672}
673
679static DVCMAN_CHANNEL* dvcman_create_channel(drdynvcPlugin* drdynvc,
680 IWTSVirtualChannelManager* pChannelMgr,
681 UINT32 ChannelId, const char* ChannelName, UINT* res)
682{
683 BOOL bAccept = 0;
684 DVCMAN_CHANNEL* channel = NULL;
685 DrdynvcClientContext* context = NULL;
686 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
687 DVCMAN_LISTENER* listener = NULL;
688 IWTSVirtualChannelCallback* pCallback = NULL;
689
690 WINPR_ASSERT(dvcman);
691 WINPR_ASSERT(res);
692
693 HashTable_Lock(dvcman->listeners);
694 listener = (DVCMAN_LISTENER*)HashTable_GetItemValue(dvcman->listeners, ChannelName);
695 if (!listener)
696 {
697 *res = ERROR_NOT_FOUND;
698 goto out;
699 }
700
701 channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
702 if (channel)
703 {
704 switch (channel->state)
705 {
706 case DVC_CHANNEL_RUNNING:
707 WLog_Print(drdynvc->log, WLOG_ERROR,
708 "Protocol error: Duplicated ChannelId %" PRIu32 " (%s)!", ChannelId,
709 ChannelName);
710 *res = CHANNEL_RC_ALREADY_OPEN;
711 goto out;
712
713 case DVC_CHANNEL_CLOSED:
714 case DVC_CHANNEL_INIT:
715 default:
716 {
717 WLog_Print(drdynvc->log, WLOG_ERROR, "not expecting a createChannel from state %s",
718 channel_state2str(channel->state));
719 *res = CHANNEL_RC_INITIALIZATION_ERROR;
720 goto out;
721 }
722 }
723 }
724 else
725 {
726 if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
727 {
728 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_channel_new failed!");
729 *res = CHANNEL_RC_NO_MEMORY;
730 goto out;
731 }
732 }
733
734 if (!HashTable_Insert(dvcman->channelsById, &channel->channel_id, channel))
735 {
736 WLog_Print(drdynvc->log, WLOG_ERROR, "unable to register channel in our channel list");
737 *res = ERROR_INTERNAL_ERROR;
738 dvcman_channel_free(channel);
739 channel = NULL;
740 goto out;
741 }
742
743 channel->iface.Write = dvcman_write_channel;
744 channel->iface.Close = dvcman_close_channel_iface;
745 bAccept = TRUE;
746
747 *res = listener->listener_callback->OnNewChannelConnection(
748 listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback);
749
750 if (*res != CHANNEL_RC_OK)
751 {
752 WLog_Print(drdynvc->log, WLOG_ERROR,
753 "OnNewChannelConnection failed with error %" PRIu32 "!", *res);
754 *res = ERROR_INTERNAL_ERROR;
755 dvcman_channel_unref(channel);
756 goto out;
757 }
758
759 if (!bAccept)
760 {
761 WLog_Print(drdynvc->log, WLOG_ERROR, "OnNewChannelConnection returned with bAccept FALSE!");
762 *res = ERROR_INTERNAL_ERROR;
763 dvcman_channel_unref(channel);
764 channel = NULL;
765 goto out;
766 }
767
768 WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s created new channel %" PRIu32 "",
769 listener->channel_name, channel->channel_id);
770 channel->state = DVC_CHANNEL_RUNNING;
771 channel->channel_callback = pCallback;
772 channel->pInterface = listener->iface.pInterface;
773 context = dvcman->drdynvc->context;
774
775 IFCALLRET(context->OnChannelConnected, *res, context, ChannelName, listener->iface.pInterface);
776 if (*res != CHANNEL_RC_OK)
777 {
778 WLog_Print(drdynvc->log, WLOG_ERROR,
779 "context.OnChannelConnected failed with error %" PRIu32 "", *res);
780 }
781
782out:
783 HashTable_Unlock(dvcman->listeners);
784
785 return channel;
786}
787
793static UINT dvcman_open_channel(drdynvcPlugin* drdynvc, DVCMAN_CHANNEL* channel)
794{
795 IWTSVirtualChannelCallback* pCallback = NULL;
796 UINT error = CHANNEL_RC_OK;
797
798 WINPR_ASSERT(drdynvc);
799 WINPR_ASSERT(channel);
800 if (channel->state == DVC_CHANNEL_RUNNING)
801 {
802 pCallback = channel->channel_callback;
803
804 if (pCallback->OnOpen)
805 {
806 check_open_close_receive(channel);
807 error = pCallback->OnOpen(pCallback);
808 if (error)
809 {
810 WLog_Print(drdynvc->log, WLOG_ERROR, "OnOpen failed with error %" PRIu32 "!",
811 error);
812 goto out;
813 }
814 }
815
816 WLog_Print(drdynvc->log, WLOG_DEBUG, "open_channel: ChannelId %" PRIu32 "",
817 channel->channel_id);
818 }
819
820out:
821 return error;
822}
823
829static UINT dvcman_receive_channel_data_first(DVCMAN_CHANNEL* channel, UINT32 length)
830{
831 WINPR_ASSERT(channel);
832 WINPR_ASSERT(channel->dvcman);
833 if (channel->dvc_data)
834 Stream_Release(channel->dvc_data);
835
836 channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
837
838 if (!channel->dvc_data)
839 {
840 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
841 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
842 return CHANNEL_RC_NO_MEMORY;
843 }
844
845 channel->dvc_data_length = length;
846 return CHANNEL_RC_OK;
847}
848
854static UINT dvcman_receive_channel_data(DVCMAN_CHANNEL* channel, wStream* data,
855 WINPR_ATTR_UNUSED UINT32 ThreadingFlags)
856{
857 UINT status = CHANNEL_RC_OK;
858 size_t dataSize = Stream_GetRemainingLength(data);
859
860 WINPR_ASSERT(channel);
861 WINPR_ASSERT(channel->dvcman);
862 if (channel->dvc_data)
863 {
864 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
865
866 /* Fragmented data */
867 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
868 {
869 WLog_Print(drdynvc->log, WLOG_ERROR, "data exceeding declared length!");
870 Stream_Release(channel->dvc_data);
871 channel->dvc_data = NULL;
872 status = ERROR_INVALID_DATA;
873 goto out;
874 }
875
876 Stream_Copy(data, channel->dvc_data, dataSize);
877
878 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
879 {
880 Stream_SealLength(channel->dvc_data);
881 Stream_SetPosition(channel->dvc_data, 0);
882
883 status = dvcman_call_on_receive(channel, channel->dvc_data);
884 Stream_Release(channel->dvc_data);
885 channel->dvc_data = NULL;
886 }
887 }
888 else
889 status = dvcman_call_on_receive(channel, data);
890
891out:
892 return status;
893}
894
895static UINT8 drdynvc_write_variable_uint(wStream* s, UINT32 val)
896{
897 UINT8 cb = 0;
898
899 if (val <= 0xFF)
900 {
901 cb = 0;
902 Stream_Write_UINT8(s, (UINT8)val);
903 }
904 else if (val <= 0xFFFF)
905 {
906 cb = 1;
907 Stream_Write_UINT16(s, (UINT16)val);
908 }
909 else
910 {
911 cb = 2;
912 Stream_Write_UINT32(s, val);
913 }
914
915 return cb;
916}
917
923static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s)
924{
925 UINT status = 0;
926
927 if (!drdynvc)
928 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
929 else
930 {
931 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelWriteEx);
932 status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(
933 drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),
934 (UINT32)Stream_GetPosition(s), s);
935 }
936
937 switch (status)
938 {
939 case CHANNEL_RC_OK:
940 return CHANNEL_RC_OK;
941
942 case CHANNEL_RC_NOT_CONNECTED:
943 Stream_Release(s);
944 return CHANNEL_RC_OK;
945
946 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
947 Stream_Release(s);
948 WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
949 return status;
950
951 default:
952 Stream_Release(s);
953 WLog_Print(drdynvc->log, WLOG_ERROR,
954 "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
955 WTSErrorToString(status), status);
956 return status;
957 }
958}
959
965static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
966 UINT32 dataSize, BOOL* close)
967{
968 wStream* data_out = NULL;
969 size_t pos = 0;
970 UINT8 cbChId = 0;
971 UINT8 cbLen = 0;
972 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
973 DVCMAN* dvcman = NULL;
974
975 if (!drdynvc)
976 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
977
978 dvcman = (DVCMAN*)drdynvc->channel_mgr;
979 WINPR_ASSERT(dvcman);
980
981 WLog_Print(drdynvc->log, WLOG_TRACE, "write_data: ChannelId=%" PRIu32 " size=%" PRIu32 "",
982 ChannelId, dataSize);
983 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
984
985 if (!data_out)
986 {
987 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
988 return CHANNEL_RC_NO_MEMORY;
989 }
990
991 Stream_SetPosition(data_out, 1);
992 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
993 pos = Stream_GetPosition(data_out);
994
995 if (dataSize == 0)
996 {
997 /* TODO: shall treat that case with write(0) that do a close */
998 *close = TRUE;
999 Stream_Release(data_out);
1000 }
1001 else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
1002 {
1003 Stream_SetPosition(data_out, 0);
1004 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1005 Stream_SetPosition(data_out, pos);
1006 Stream_Write(data_out, data, dataSize);
1007 status = drdynvc_send(drdynvc, data_out);
1008 }
1009 else
1010 {
1011 /* Fragment the data */
1012 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
1013 pos = Stream_GetPosition(data_out);
1014 Stream_SetPosition(data_out, 0);
1015
1016 const INT32 pdu = (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2);
1017 Stream_Write_UINT8(data_out, WINPR_ASSERTING_INT_CAST(UINT8, pdu));
1018 Stream_SetPosition(data_out, pos);
1019
1020 {
1021 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1022 const uint32_t chunkLength =
1023 CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1024 Stream_Write(data_out, data, chunkLength);
1025
1026 data += chunkLength;
1027 dataSize -= chunkLength;
1028 }
1029 status = drdynvc_send(drdynvc, data_out);
1030
1031 while (status == CHANNEL_RC_OK && dataSize > 0)
1032 {
1033 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
1034
1035 if (!data_out)
1036 {
1037 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1038 return CHANNEL_RC_NO_MEMORY;
1039 }
1040
1041 Stream_SetPosition(data_out, 1);
1042 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
1043 pos = Stream_GetPosition(data_out);
1044 Stream_SetPosition(data_out, 0);
1045 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1046 Stream_SetPosition(data_out, pos);
1047
1048 uint32_t chunkLength = dataSize;
1049
1050 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1051 if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)
1052 chunkLength = CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1053
1054 Stream_Write(data_out, data, chunkLength);
1055 data += chunkLength;
1056 dataSize -= chunkLength;
1057 status = drdynvc_send(drdynvc, data_out);
1058 }
1059 }
1060
1061 if (status != CHANNEL_RC_OK)
1062 {
1063 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1064 WTSErrorToString(status), status);
1065 return status;
1066 }
1067
1068 return CHANNEL_RC_OK;
1069}
1070
1076static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
1077{
1078 UINT status = 0;
1079 wStream* s = NULL;
1080 DVCMAN* dvcman = NULL;
1081
1082 if (!drdynvc)
1083 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1084
1085 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1086 WINPR_ASSERT(dvcman);
1087
1088 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_response");
1089 s = StreamPool_Take(dvcman->pool, 4);
1090
1091 if (!s)
1092 {
1093 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_Ndrdynvc_write_variable_uintew failed!");
1094 return CHANNEL_RC_NO_MEMORY;
1095 }
1096
1097 Stream_Write_UINT16(s, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
1098 Stream_Write_UINT16(s, drdynvc->version);
1099 status = drdynvc_send(drdynvc, s);
1100
1101 if (status != CHANNEL_RC_OK)
1102 {
1103 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1104 WTSErrorToString(status), status);
1105 }
1106
1107 return status;
1108}
1109
1115static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId,
1116 wStream* s)
1117{
1118 UINT status = 0;
1119
1120 if (!drdynvc)
1121 return CHANNEL_RC_BAD_INIT_HANDLE;
1122
1123 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
1124 return ERROR_INVALID_DATA;
1125
1126 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_request Sp=%d cbChId=%d", Sp, cbChId);
1127 Stream_Seek(s, 1); /* pad */
1128 Stream_Read_UINT16(s, drdynvc->version);
1129
1130 /* RDP8 servers offer version 3, though Microsoft forgot to document it
1131 * in their early documents. It behaves the same as version 2.
1132 */
1133 if ((drdynvc->version == 2) || (drdynvc->version == 3))
1134 {
1135 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1136 return ERROR_INVALID_DATA;
1137
1138 Stream_Read_UINT16(s, drdynvc->PriorityCharge0);
1139 Stream_Read_UINT16(s, drdynvc->PriorityCharge1);
1140 Stream_Read_UINT16(s, drdynvc->PriorityCharge2);
1141 Stream_Read_UINT16(s, drdynvc->PriorityCharge3);
1142 }
1143
1144 status = drdynvc_send_capability_response(drdynvc);
1145 drdynvc->state = DRDYNVC_STATE_READY;
1146 return status;
1147}
1148
1149static UINT32 drdynvc_cblen_to_bytes(int cbLen)
1150{
1151 switch (cbLen)
1152 {
1153 case 0:
1154 return 1;
1155
1156 case 1:
1157 return 2;
1158
1159 default:
1160 return 4;
1161 }
1162}
1163
1164static UINT32 drdynvc_read_variable_uint(wStream* s, int cbLen)
1165{
1166 UINT32 val = 0;
1167
1168 switch (cbLen)
1169 {
1170 case 0:
1171 Stream_Read_UINT8(s, val);
1172 break;
1173
1174 case 1:
1175 Stream_Read_UINT16(s, val);
1176 break;
1177
1178 default:
1179 Stream_Read_UINT32(s, val);
1180 break;
1181 }
1182
1183 return val;
1184}
1185
1191static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, UINT8 Sp, UINT8 cbChId,
1192 wStream* s)
1193{
1194 UINT status = 0;
1195 wStream* data_out = NULL;
1196 UINT channel_status = 0;
1197 DVCMAN* dvcman = NULL;
1198 DVCMAN_CHANNEL* channel = NULL;
1199 INT32 retStatus = 0;
1200
1201 WINPR_UNUSED(Sp);
1202 if (!drdynvc)
1203 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1204
1205 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1206 WINPR_ASSERT(dvcman);
1207
1208 if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1209 {
1215 drdynvc->version = 3;
1216
1217 if ((status = drdynvc_send_capability_response(drdynvc)))
1218 {
1219 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_send_capability_response failed!");
1220 return status;
1221 }
1222
1223 drdynvc->state = DRDYNVC_STATE_READY;
1224 }
1225
1226 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1227 return ERROR_INVALID_DATA;
1228
1229 const UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1230 const size_t pos = Stream_GetPosition(s);
1231 const char* name = Stream_ConstPointer(s);
1232 const size_t length = Stream_GetRemainingLength(s);
1233
1234 if (strnlen(name, length) >= length)
1235 return ERROR_INVALID_DATA;
1236
1237 WLog_Print(drdynvc->log, WLOG_DEBUG,
1238 "process_create_request: ChannelId=%" PRIu32 " ChannelName=%s", ChannelId, name);
1239
1240 data_out = StreamPool_Take(dvcman->pool, pos + 4);
1241 if (!data_out)
1242 {
1243 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1244 return CHANNEL_RC_NO_MEMORY;
1245 }
1246
1247 Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1248 Stream_SetPosition(s, 1);
1249 Stream_Copy(s, data_out, pos - 1);
1250
1251 channel =
1252 dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name, &channel_status);
1253 switch (channel_status)
1254 {
1255 case CHANNEL_RC_OK:
1256 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel created");
1257 retStatus = 0;
1258 break;
1259 case CHANNEL_RC_NO_MEMORY:
1260 WLog_Print(drdynvc->log, WLOG_DEBUG, "not enough memory for channel creation");
1261 retStatus = STATUS_NO_MEMORY;
1262 break;
1263 case ERROR_NOT_FOUND:
1264 WLog_Print(drdynvc->log, WLOG_DEBUG, "no listener for '%s'", name);
1265 retStatus = STATUS_NOT_FOUND; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1266 break;
1267 default:
1268 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel creation error");
1269 retStatus = STATUS_UNSUCCESSFUL; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1270 break;
1271 }
1272 Stream_Write_INT32(data_out, retStatus);
1273
1274 status = drdynvc_send(drdynvc, data_out);
1275 if (status != CHANNEL_RC_OK)
1276 {
1277 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1278 WTSErrorToString(status), status);
1279 dvcman_channel_unref(channel);
1280 return status;
1281 }
1282
1283 if (channel_status == CHANNEL_RC_OK)
1284 {
1285 if ((status = dvcman_open_channel(drdynvc, channel)))
1286 {
1287 WLog_Print(drdynvc->log, WLOG_ERROR,
1288 "dvcman_open_channel failed with error %" PRIu32 "!", status);
1289 return status;
1290 }
1291 }
1292
1293 return status;
1294}
1295
1301static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1302 BOOL compressed, UINT32 ThreadingFlags)
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 UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1310 UINT32 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 DVCMAN_CHANNEL* 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 UINT status = CHANNEL_RC_OK;
1328 BOOL shouldFree = FALSE;
1329 if (channel->state != DVC_CHANNEL_RUNNING)
1330 goto out;
1331
1332 if (compressed)
1333 {
1334 BYTE* data = NULL;
1335 UINT32 dataSize = 0;
1336 if (zgfx_decompress(channel->decompressor, Stream_Pointer(s),
1337 WINPR_ASSERTING_INT_CAST(UINT32, Stream_GetRemainingLength(s)), &data,
1338 &dataSize, 0) < 0)
1339 {
1340 status = ERROR_INVALID_DATA;
1341 WLog_Print(drdynvc->log, WLOG_ERROR, "error de-compressing first packet");
1342 goto out;
1343 }
1344
1345 s = Stream_New(data, dataSize);
1346 if (!s)
1347 {
1348 status = CHANNEL_RC_NO_MEMORY;
1349 WLog_Print(drdynvc->log, WLOG_ERROR, "error allocating new Stream(len=%" PRIu32 ")",
1350 dataSize);
1351 free(data);
1352 goto out;
1353 }
1354 shouldFree = TRUE;
1355 }
1356
1357 status = dvcman_receive_channel_data_first(channel, Length);
1358
1359 if (status == CHANNEL_RC_OK)
1360 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1361
1362 if (status != CHANNEL_RC_OK)
1363 status = dvcman_channel_close(channel, FALSE, FALSE);
1364
1365out:
1366 if (shouldFree)
1367 Stream_Free(s, TRUE);
1368 dvcman_channel_unref(channel);
1369 return status;
1370}
1371
1377static UINT drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1378 BOOL compressed, UINT32 ThreadingFlags)
1379{
1380 WINPR_ASSERT(drdynvc);
1381 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1382 return ERROR_INVALID_DATA;
1383
1384 UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1385 WLog_Print(drdynvc->log, WLOG_TRACE, "process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp,
1386 cbChId, ChannelId);
1387
1388 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1389 if (!channel)
1390 {
1396 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
1397 return CHANNEL_RC_OK;
1398 }
1399
1400 BOOL shouldFree = FALSE;
1401 UINT status = CHANNEL_RC_OK;
1402 if (channel->state != DVC_CHANNEL_RUNNING)
1403 goto out;
1404
1405 if (compressed)
1406 {
1407 BYTE* data = NULL;
1408 UINT32 dataSize = 0;
1409
1410 if (zgfx_decompress(channel->decompressor, Stream_Pointer(s),
1411 WINPR_ASSERTING_INT_CAST(UINT32, Stream_GetRemainingLength(s)), &data,
1412 &dataSize, 0) < 0)
1413 {
1414 status = ERROR_INVALID_DATA;
1415 WLog_Print(drdynvc->log, WLOG_ERROR, "error de-compressing data packet");
1416 goto out;
1417 }
1418
1419 s = Stream_New(data, dataSize);
1420 if (!s)
1421 {
1422 status = CHANNEL_RC_NO_MEMORY;
1423 WLog_Print(drdynvc->log, WLOG_ERROR, "error allocating new Stream(len=%" PRIu32 ")",
1424 dataSize);
1425 free(data);
1426 goto out;
1427 }
1428 shouldFree = TRUE;
1429 }
1430
1431 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1432 if (status != CHANNEL_RC_OK)
1433 status = dvcman_channel_close(channel, FALSE, FALSE);
1434
1435out:
1436 if (shouldFree)
1437 Stream_Free(s, TRUE);
1438 dvcman_channel_unref(channel);
1439 return status;
1440}
1441
1447static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1448{
1449 UINT32 ChannelId = 0;
1450 DVCMAN_CHANNEL* channel = NULL;
1451
1452 WINPR_ASSERT(drdynvc);
1453 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1454 return ERROR_INVALID_DATA;
1455
1456 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1457 WLog_Print(drdynvc->log, WLOG_DEBUG,
1458 "process_close_request: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp, cbChId,
1459 ChannelId);
1460
1461 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1462 if (!channel)
1463 {
1464 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_close_request channel %" PRIu32 " not present",
1465 ChannelId);
1466 return CHANNEL_RC_OK;
1467 }
1468
1469 dvcman_channel_close(channel, TRUE, FALSE);
1470 dvcman_channel_unref(channel);
1471 return CHANNEL_RC_OK;
1472}
1473
1479static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc, wStream* s, UINT32 ThreadingFlags)
1480{
1481 WINPR_ASSERT(drdynvc);
1482 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1483 return ERROR_INVALID_DATA;
1484
1485 UINT8 value = Stream_Get_UINT8(s);
1486 const UINT8 Cmd = (value & 0xf0) >> 4;
1487 const UINT8 Sp = (value & 0x0c) >> 2;
1488 const UINT8 cbChId = (value & 0x03) >> 0;
1489 WLog_Print(drdynvc->log, WLOG_TRACE, "order_recv: Cmd=%s, Sp=%" PRIu8 " cbChId=%" PRIu8,
1490 drdynvc_get_packet_type(Cmd), Sp, cbChId);
1491
1492 switch (Cmd)
1493 {
1494 case CAPABILITY_REQUEST_PDU:
1495 return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1496
1497 case CREATE_REQUEST_PDU:
1498 return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1499
1500 case DATA_FIRST_PDU:
1501 case DATA_FIRST_COMPRESSED_PDU:
1502 return drdynvc_process_data_first(drdynvc, Sp, cbChId, s,
1503 (Cmd == DATA_FIRST_COMPRESSED_PDU), ThreadingFlags);
1504
1505 case DATA_PDU:
1506 case DATA_COMPRESSED_PDU:
1507 return drdynvc_process_data(drdynvc, Sp, cbChId, s, (Cmd == DATA_COMPRESSED_PDU),
1508 ThreadingFlags);
1509
1510 case CLOSE_REQUEST_PDU:
1511 return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1512
1513 case SOFT_SYNC_RESPONSE_PDU:
1514 WLog_Print(drdynvc->log, WLOG_ERROR,
1515 "not expecting a SOFT_SYNC_RESPONSE_PDU as a client");
1516 return ERROR_INTERNAL_ERROR;
1517
1518 default:
1519 WLog_Print(drdynvc->log, WLOG_ERROR, "unknown drdynvc cmd 0x%x", Cmd);
1520 return ERROR_INTERNAL_ERROR;
1521 }
1522}
1523
1529static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc, void* pData,
1530 UINT32 dataLength, UINT32 totalLength,
1531 UINT32 dataFlags)
1532{
1533 wStream* data_in = NULL;
1534
1535 WINPR_ASSERT(drdynvc);
1536 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1537 {
1538 return CHANNEL_RC_OK;
1539 }
1540
1541 if (dataFlags & CHANNEL_FLAG_FIRST)
1542 {
1543 DVCMAN* mgr = (DVCMAN*)drdynvc->channel_mgr;
1544 if (drdynvc->data_in)
1545 Stream_Release(drdynvc->data_in);
1546
1547 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1548 }
1549
1550 if (!(data_in = drdynvc->data_in))
1551 {
1552 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1553 return CHANNEL_RC_NO_MEMORY;
1554 }
1555
1556 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1557 {
1558 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
1559 Stream_Release(drdynvc->data_in);
1560 drdynvc->data_in = NULL;
1561 return ERROR_INTERNAL_ERROR;
1562 }
1563
1564 Stream_Write(data_in, pData, dataLength);
1565
1566 if (dataFlags & CHANNEL_FLAG_LAST)
1567 {
1568 const size_t cap = Stream_Capacity(data_in);
1569 const size_t pos = Stream_GetPosition(data_in);
1570 if (cap < pos)
1571 {
1572 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_plugin_process_received: read error");
1573 return ERROR_INVALID_DATA;
1574 }
1575
1576 drdynvc->data_in = NULL;
1577 Stream_SealLength(data_in);
1578 Stream_SetPosition(data_in, 0);
1579
1580 if (drdynvc->async)
1581 {
1582 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (void*)data_in, NULL))
1583 {
1584 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Post failed!");
1585 return ERROR_INTERNAL_ERROR;
1586 }
1587 }
1588 else
1589 {
1590 UINT error = drdynvc_order_recv(drdynvc, data_in, TRUE);
1591 Stream_Release(data_in);
1592
1593 if (error)
1594 {
1595 WLog_Print(drdynvc->log, WLOG_WARN,
1596 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1597 }
1598 }
1599 }
1600
1601 return CHANNEL_RC_OK;
1602}
1603
1604static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1605 UINT event, LPVOID pData,
1606 UINT32 dataLength, UINT32 totalLength,
1607 UINT32 dataFlags)
1608{
1609 UINT error = CHANNEL_RC_OK;
1610 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1611
1612 WINPR_ASSERT(drdynvc);
1613 switch (event)
1614 {
1615 case CHANNEL_EVENT_DATA_RECEIVED:
1616 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1617 {
1618 WLog_ERR(TAG, "drdynvc_virtual_channel_open_event: error no match");
1619 return;
1620 }
1621 if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1622 totalLength, dataFlags)))
1623 WLog_Print(drdynvc->log, WLOG_ERROR,
1624 "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1625 "",
1626 error);
1627
1628 break;
1629
1630 case CHANNEL_EVENT_WRITE_CANCELLED:
1631 case CHANNEL_EVENT_WRITE_COMPLETE:
1632 {
1633 wStream* s = (wStream*)pData;
1634 Stream_Release(s);
1635 }
1636 break;
1637
1638 case CHANNEL_EVENT_USER:
1639 break;
1640 default:
1641 break;
1642 }
1643
1644 if (error && drdynvc && drdynvc->rdpcontext)
1645 setChannelError(drdynvc->rdpcontext, error,
1646 "drdynvc_virtual_channel_open_event reported an error");
1647}
1648
1649static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1650{
1651 /* TODO: rewrite this */
1652 wStream* data = NULL;
1653 wMessage message = { 0 };
1654 UINT error = CHANNEL_RC_OK;
1655 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1656
1657 if (!drdynvc)
1658 {
1659 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1660 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1661 }
1662
1663 while (1)
1664 {
1665 if (!MessageQueue_Wait(drdynvc->queue))
1666 {
1667 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Wait failed!");
1668 error = ERROR_INTERNAL_ERROR;
1669 break;
1670 }
1671
1672 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1673 {
1674 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Peek failed!");
1675 error = ERROR_INTERNAL_ERROR;
1676 break;
1677 }
1678
1679 if (message.id == WMQ_QUIT)
1680 break;
1681
1682 if (message.id == 0)
1683 {
1684 UINT32 ThreadingFlags = TRUE;
1685 data = (wStream*)message.wParam;
1686
1687 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1688 {
1689 WLog_Print(drdynvc->log, WLOG_WARN,
1690 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1691 }
1692
1693 Stream_Release(data);
1694 }
1695 }
1696
1697 {
1698 /* Disconnect remaining dynamic channels that the server did not.
1699 * This is required to properly shut down channels by calling the appropriate
1700 * event handlers. */
1701 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1702
1703 HashTable_Clear(drdynvcMgr->channelsById);
1704 }
1705
1706 if (error && drdynvc->rdpcontext)
1707 setChannelError(drdynvc->rdpcontext, error,
1708 "drdynvc_virtual_channel_client_thread reported an error");
1709
1710 ExitThread((DWORD)error);
1711 return error;
1712}
1713
1714static void drdynvc_queue_object_free(void* obj)
1715{
1716 wStream* s = NULL;
1717 wMessage* msg = (wMessage*)obj;
1718
1719 if (!msg || (msg->id != 0))
1720 return;
1721
1722 s = (wStream*)msg->wParam;
1723
1724 if (s)
1725 Stream_Release(s);
1726}
1727
1728static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1729 UINT32 dataLength)
1730{
1731 wObject* obj = NULL;
1732 WINPR_UNUSED(pData);
1733 WINPR_UNUSED(dataLength);
1734
1735 if (!drdynvc)
1736 goto error;
1737
1738 drdynvc->queue = MessageQueue_New(NULL);
1739
1740 if (!drdynvc->queue)
1741 {
1742 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_New failed!");
1743 goto error;
1744 }
1745
1746 obj = MessageQueue_Object(drdynvc->queue);
1747 obj->fnObjectFree = drdynvc_queue_object_free;
1748 drdynvc->channel_mgr = dvcman_new(drdynvc);
1749
1750 if (!drdynvc->channel_mgr)
1751 {
1752 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_new failed!");
1753 goto error;
1754 }
1755
1756 return CHANNEL_RC_OK;
1757error:
1758 return ERROR_INTERNAL_ERROR;
1759}
1760
1766static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1767 UINT32 dataLength)
1768{
1769 UINT error = 0;
1770 UINT32 status = 0;
1771 rdpSettings* settings = NULL;
1772
1773 WINPR_ASSERT(drdynvc);
1774 WINPR_UNUSED(pData);
1775 WINPR_UNUSED(dataLength);
1776
1777 if (!drdynvc)
1778 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1779
1780 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelOpenEx);
1781 status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1782 drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1783 drdynvc_virtual_channel_open_event_ex);
1784
1785 if (status != CHANNEL_RC_OK)
1786 {
1787 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelOpen failed with %s [%08" PRIX32 "]",
1788 WTSErrorToString(status), status);
1789 return status;
1790 }
1791
1792 WINPR_ASSERT(drdynvc->rdpcontext);
1793 settings = drdynvc->rdpcontext->settings;
1794 WINPR_ASSERT(settings);
1795
1796 for (UINT32 index = 0;
1797 index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
1798 {
1799 const ADDIN_ARGV* args =
1800 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1801 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1802
1803 if (CHANNEL_RC_OK != error)
1804 goto error;
1805 }
1806
1807 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1808 {
1809 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_init failed with error %" PRIu32 "!", error);
1810 goto error;
1811 }
1812
1813 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1814
1815 if (drdynvc->async)
1816 {
1817 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1818 (void*)drdynvc, 0, NULL)))
1819 {
1820 error = ERROR_INTERNAL_ERROR;
1821 WLog_Print(drdynvc->log, WLOG_ERROR, "CreateThread failed!");
1822 goto error;
1823 }
1824
1825 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1826 WLog_Print(drdynvc->log, WLOG_WARN, "SetThreadPriority failed, ignoring.");
1827 }
1828
1829error:
1830 return error;
1831}
1832
1838static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1839{
1840 UINT status = 0;
1841
1842 if (!drdynvc)
1843 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1844
1845 if (drdynvc->OpenHandle == 0)
1846 return CHANNEL_RC_OK;
1847
1848 if (drdynvc->queue)
1849 {
1850 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1851 {
1852 status = GetLastError();
1853 WLog_Print(drdynvc->log, WLOG_ERROR,
1854 "MessageQueue_PostQuit failed with error %" PRIu32 "", status);
1855 return status;
1856 }
1857 }
1858
1859 if (drdynvc->thread)
1860 {
1861 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1862 {
1863 status = GetLastError();
1864 WLog_Print(drdynvc->log, WLOG_ERROR,
1865 "WaitForSingleObject failed with error %" PRIu32 "", status);
1866 return status;
1867 }
1868
1869 (void)CloseHandle(drdynvc->thread);
1870 drdynvc->thread = NULL;
1871 }
1872 else
1873 {
1874 {
1875 /* Disconnect remaining dynamic channels that the server did not.
1876 * This is required to properly shut down channels by calling the appropriate
1877 * event handlers. */
1878 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1879
1880 HashTable_Clear(drdynvcMgr->channelsById);
1881 }
1882 }
1883
1884 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1885 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1886 drdynvc->OpenHandle);
1887
1888 if (status != CHANNEL_RC_OK)
1889 {
1890 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1891 WTSErrorToString(status), status);
1892 }
1893
1894 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1895 if (drdynvc->queue)
1896 MessageQueue_Clear(drdynvc->queue);
1897 drdynvc->OpenHandle = 0;
1898
1899 if (drdynvc->data_in)
1900 {
1901 Stream_Release(drdynvc->data_in);
1902 drdynvc->data_in = NULL;
1903 }
1904
1905 return status;
1906}
1907
1913static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1914{
1915 if (!drdynvc)
1916 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1917
1918 MessageQueue_Free(drdynvc->queue);
1919 drdynvc->queue = NULL;
1920
1921 if (drdynvc->channel_mgr)
1922 {
1923 dvcman_free(drdynvc, drdynvc->channel_mgr);
1924 drdynvc->channel_mgr = NULL;
1925 }
1926 drdynvc->InitHandle = 0;
1927 free(drdynvc->context);
1928 free(drdynvc);
1929 return CHANNEL_RC_OK;
1930}
1931
1932static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1933{
1934 UINT error = CHANNEL_RC_OK;
1935 DVCMAN* dvcman = NULL;
1936
1937 if (!drdynvc)
1938 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1939
1940 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1941
1942 if (!dvcman)
1943 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1944
1945 ArrayList_Lock(dvcman->plugins);
1946 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1947 {
1948 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1949
1950 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1951 if (error != CHANNEL_RC_OK)
1952 {
1953 WLog_Print(drdynvc->log, WLOG_ERROR, "Attach failed with error %" PRIu32 "!", error);
1954 goto fail;
1955 }
1956 }
1957
1958fail:
1959 ArrayList_Unlock(dvcman->plugins);
1960 return error;
1961}
1962
1963static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1964{
1965 UINT error = CHANNEL_RC_OK;
1966 DVCMAN* dvcman = NULL;
1967
1968 if (!drdynvc)
1969 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1970
1971 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1972
1973 if (!dvcman)
1974 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1975
1976 ArrayList_Lock(dvcman->plugins);
1977 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1978 {
1979 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1980
1981 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1982 if (error != CHANNEL_RC_OK)
1983 {
1984 WLog_Print(drdynvc->log, WLOG_ERROR, "Detach failed with error %" PRIu32 "!", error);
1985 goto fail;
1986 }
1987 }
1988
1989fail:
1990 ArrayList_Unlock(dvcman->plugins);
1991
1992 return error;
1993}
1994
1995static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1996 UINT event, LPVOID pData,
1997 UINT dataLength)
1998{
1999 UINT error = CHANNEL_RC_OK;
2000 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
2001
2002 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
2003 {
2004 WLog_ERR(TAG, "drdynvc_virtual_channel_init_event: error no match");
2005 return;
2006 }
2007
2008 switch (event)
2009 {
2010 case CHANNEL_EVENT_INITIALIZED:
2011 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
2012 break;
2013 case CHANNEL_EVENT_CONNECTED:
2014 if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
2015 WLog_Print(drdynvc->log, WLOG_ERROR,
2016 "drdynvc_virtual_channel_event_connected failed with error %" PRIu32 "",
2017 error);
2018
2019 break;
2020
2021 case CHANNEL_EVENT_DISCONNECTED:
2022 if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
2023 WLog_Print(drdynvc->log, WLOG_ERROR,
2024 "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
2025 "",
2026 error);
2027
2028 break;
2029
2030 case CHANNEL_EVENT_TERMINATED:
2031 if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
2032 WLog_Print(drdynvc->log, WLOG_ERROR,
2033 "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32 "",
2034 error);
2035
2036 break;
2037
2038 case CHANNEL_EVENT_ATTACHED:
2039 if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
2040 WLog_Print(drdynvc->log, WLOG_ERROR,
2041 "drdynvc_virtual_channel_event_attached failed with error %" PRIu32 "",
2042 error);
2043
2044 break;
2045
2046 case CHANNEL_EVENT_DETACHED:
2047 if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
2048 WLog_Print(drdynvc->log, WLOG_ERROR,
2049 "drdynvc_virtual_channel_event_detached failed with error %" PRIu32 "",
2050 error);
2051
2052 break;
2053
2054 default:
2055 break;
2056 }
2057
2058 if (error && drdynvc->rdpcontext)
2059 setChannelError(drdynvc->rdpcontext, error,
2060 "drdynvc_virtual_channel_init_event_ex reported an error");
2061}
2062
2067static int drdynvc_get_version(DrdynvcClientContext* context)
2068{
2069 WINPR_ASSERT(context);
2070 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
2071 WINPR_ASSERT(drdynvc);
2072 return drdynvc->version;
2073}
2074
2075/* drdynvc is always built-in */
2076#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
2077
2078FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2079 PVOID pInitHandle))
2080{
2081 UINT rc = 0;
2082 drdynvcPlugin* drdynvc = NULL;
2083 DrdynvcClientContext* context = NULL;
2084 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = NULL;
2085 drdynvc = (drdynvcPlugin*)calloc(1, sizeof(drdynvcPlugin));
2086
2087 WINPR_ASSERT(pEntryPoints);
2088 if (!drdynvc)
2089 {
2090 WLog_ERR(TAG, "calloc failed!");
2091 return FALSE;
2092 }
2093
2094 drdynvc->channelDef.options =
2095 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2096 (void)sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name),
2097 DRDYNVC_SVC_CHANNEL_NAME);
2098 drdynvc->state = DRDYNVC_STATE_INITIAL;
2099 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2100
2101 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2102 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2103 {
2104 context = (DrdynvcClientContext*)calloc(1, sizeof(DrdynvcClientContext));
2105
2106 if (!context)
2107 {
2108 WLog_Print(drdynvc->log, WLOG_ERROR, "calloc failed!");
2109 free(drdynvc);
2110 return FALSE;
2111 }
2112
2113 context->handle = (void*)drdynvc;
2114 context->custom = NULL;
2115 drdynvc->context = context;
2116 context->GetVersion = drdynvc_get_version;
2117 drdynvc->rdpcontext = pEntryPointsEx->context;
2118 if (!freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2119 FreeRDP_TransportDumpReplay) &&
2120 !freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2121 FreeRDP_SynchronousDynamicChannels))
2122 drdynvc->async = TRUE;
2123 }
2124
2125 drdynvc->log = WLog_Get(TAG);
2126 WLog_Print(drdynvc->log, WLOG_DEBUG, "VirtualChannelEntryEx");
2127 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2128 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
2129 drdynvc->InitHandle = pInitHandle;
2130
2131 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelInitEx);
2132 rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
2133 drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2134 drdynvc_virtual_channel_init_event_ex);
2135
2136 if (CHANNEL_RC_OK != rc)
2137 {
2138 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
2139 WTSErrorToString(rc), rc);
2140 free(drdynvc->context);
2141 free(drdynvc);
2142 return FALSE;
2143 }
2144
2145 drdynvc->channelEntryPoints.pInterface = context;
2146 return TRUE;
2147}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
ADDIN_ARGV
Definition settings_types.h:367
CHANNEL_ENTRY_POINTS_FREERDP_EX
Definition svc.h:60
DVCMAN_CHANNEL
Definition client/drdynvc_main.h:82
DVCMAN_ENTRY_POINTS
Definition client/drdynvc_main.h:66
DVCMAN_LISTENER
Definition client/drdynvc_main.h:56
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:57