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 return error;
1598 }
1599 }
1600 }
1601
1602 return CHANNEL_RC_OK;
1603}
1604
1605static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1606 UINT event, LPVOID pData,
1607 UINT32 dataLength, UINT32 totalLength,
1608 UINT32 dataFlags)
1609{
1610 UINT error = CHANNEL_RC_OK;
1611 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1612
1613 WINPR_ASSERT(drdynvc);
1614 switch (event)
1615 {
1616 case CHANNEL_EVENT_DATA_RECEIVED:
1617 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1618 {
1619 WLog_ERR(TAG, "drdynvc_virtual_channel_open_event: error no match");
1620 return;
1621 }
1622 if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1623 totalLength, dataFlags)))
1624 WLog_Print(drdynvc->log, WLOG_ERROR,
1625 "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1626 "",
1627 error);
1628
1629 break;
1630
1631 case CHANNEL_EVENT_WRITE_CANCELLED:
1632 case CHANNEL_EVENT_WRITE_COMPLETE:
1633 {
1634 wStream* s = (wStream*)pData;
1635 Stream_Release(s);
1636 }
1637 break;
1638
1639 case CHANNEL_EVENT_USER:
1640 break;
1641 default:
1642 break;
1643 }
1644
1645 if (error && drdynvc && drdynvc->rdpcontext)
1646 setChannelError(drdynvc->rdpcontext, error,
1647 "drdynvc_virtual_channel_open_event reported an error");
1648}
1649
1650static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1651{
1652 /* TODO: rewrite this */
1653 wStream* data = NULL;
1654 wMessage message = { 0 };
1655 UINT error = CHANNEL_RC_OK;
1656 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1657
1658 if (!drdynvc)
1659 {
1660 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1661 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1662 }
1663
1664 while (1)
1665 {
1666 if (!MessageQueue_Wait(drdynvc->queue))
1667 {
1668 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Wait failed!");
1669 error = ERROR_INTERNAL_ERROR;
1670 break;
1671 }
1672
1673 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1674 {
1675 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Peek failed!");
1676 error = ERROR_INTERNAL_ERROR;
1677 break;
1678 }
1679
1680 if (message.id == WMQ_QUIT)
1681 break;
1682
1683 if (message.id == 0)
1684 {
1685 UINT32 ThreadingFlags = TRUE;
1686 data = (wStream*)message.wParam;
1687
1688 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1689 {
1690 WLog_Print(drdynvc->log, WLOG_WARN,
1691 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1692 }
1693
1694 Stream_Release(data);
1695 }
1696 }
1697
1698 {
1699 /* Disconnect remaining dynamic channels that the server did not.
1700 * This is required to properly shut down channels by calling the appropriate
1701 * event handlers. */
1702 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1703
1704 HashTable_Clear(drdynvcMgr->channelsById);
1705 }
1706
1707 if (error && drdynvc->rdpcontext)
1708 setChannelError(drdynvc->rdpcontext, error,
1709 "drdynvc_virtual_channel_client_thread reported an error");
1710
1711 ExitThread((DWORD)error);
1712 return error;
1713}
1714
1715static void drdynvc_queue_object_free(void* obj)
1716{
1717 wStream* s = NULL;
1718 wMessage* msg = (wMessage*)obj;
1719
1720 if (!msg || (msg->id != 0))
1721 return;
1722
1723 s = (wStream*)msg->wParam;
1724
1725 if (s)
1726 Stream_Release(s);
1727}
1728
1729static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1730 UINT32 dataLength)
1731{
1732 wObject* obj = NULL;
1733 WINPR_UNUSED(pData);
1734 WINPR_UNUSED(dataLength);
1735
1736 if (!drdynvc)
1737 goto error;
1738
1739 drdynvc->queue = MessageQueue_New(NULL);
1740
1741 if (!drdynvc->queue)
1742 {
1743 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_New failed!");
1744 goto error;
1745 }
1746
1747 obj = MessageQueue_Object(drdynvc->queue);
1748 obj->fnObjectFree = drdynvc_queue_object_free;
1749 drdynvc->channel_mgr = dvcman_new(drdynvc);
1750
1751 if (!drdynvc->channel_mgr)
1752 {
1753 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_new failed!");
1754 goto error;
1755 }
1756
1757 return CHANNEL_RC_OK;
1758error:
1759 return ERROR_INTERNAL_ERROR;
1760}
1761
1767static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1768 UINT32 dataLength)
1769{
1770 UINT error = 0;
1771 UINT32 status = 0;
1772 rdpSettings* settings = NULL;
1773
1774 WINPR_ASSERT(drdynvc);
1775 WINPR_UNUSED(pData);
1776 WINPR_UNUSED(dataLength);
1777
1778 if (!drdynvc)
1779 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1780
1781 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelOpenEx);
1782 status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1783 drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1784 drdynvc_virtual_channel_open_event_ex);
1785
1786 if (status != CHANNEL_RC_OK)
1787 {
1788 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelOpen failed with %s [%08" PRIX32 "]",
1789 WTSErrorToString(status), status);
1790 return status;
1791 }
1792
1793 WINPR_ASSERT(drdynvc->rdpcontext);
1794 settings = drdynvc->rdpcontext->settings;
1795 WINPR_ASSERT(settings);
1796
1797 for (UINT32 index = 0;
1798 index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
1799 {
1800 const ADDIN_ARGV* args =
1801 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1802 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1803
1804 if (CHANNEL_RC_OK != error)
1805 goto error;
1806 }
1807
1808 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1809 {
1810 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_init failed with error %" PRIu32 "!", error);
1811 goto error;
1812 }
1813
1814 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1815
1816 if (drdynvc->async)
1817 {
1818 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1819 (void*)drdynvc, 0, NULL)))
1820 {
1821 error = ERROR_INTERNAL_ERROR;
1822 WLog_Print(drdynvc->log, WLOG_ERROR, "CreateThread failed!");
1823 goto error;
1824 }
1825
1826 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1827 WLog_Print(drdynvc->log, WLOG_WARN, "SetThreadPriority failed, ignoring.");
1828 }
1829
1830error:
1831 return error;
1832}
1833
1839static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1840{
1841 UINT status = 0;
1842
1843 if (!drdynvc)
1844 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1845
1846 if (drdynvc->OpenHandle == 0)
1847 return CHANNEL_RC_OK;
1848
1849 if (drdynvc->queue)
1850 {
1851 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1852 {
1853 status = GetLastError();
1854 WLog_Print(drdynvc->log, WLOG_ERROR,
1855 "MessageQueue_PostQuit failed with error %" PRIu32 "", status);
1856 return status;
1857 }
1858 }
1859
1860 if (drdynvc->thread)
1861 {
1862 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1863 {
1864 status = GetLastError();
1865 WLog_Print(drdynvc->log, WLOG_ERROR,
1866 "WaitForSingleObject failed with error %" PRIu32 "", status);
1867 return status;
1868 }
1869
1870 (void)CloseHandle(drdynvc->thread);
1871 drdynvc->thread = NULL;
1872 }
1873 else
1874 {
1875 {
1876 /* Disconnect remaining dynamic channels that the server did not.
1877 * This is required to properly shut down channels by calling the appropriate
1878 * event handlers. */
1879 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1880
1881 HashTable_Clear(drdynvcMgr->channelsById);
1882 }
1883 }
1884
1885 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1886 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1887 drdynvc->OpenHandle);
1888
1889 if (status != CHANNEL_RC_OK)
1890 {
1891 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1892 WTSErrorToString(status), status);
1893 }
1894
1895 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1896 if (drdynvc->queue)
1897 MessageQueue_Clear(drdynvc->queue);
1898 drdynvc->OpenHandle = 0;
1899
1900 if (drdynvc->data_in)
1901 {
1902 Stream_Release(drdynvc->data_in);
1903 drdynvc->data_in = NULL;
1904 }
1905
1906 return status;
1907}
1908
1914static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1915{
1916 if (!drdynvc)
1917 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1918
1919 MessageQueue_Free(drdynvc->queue);
1920 drdynvc->queue = NULL;
1921
1922 if (drdynvc->channel_mgr)
1923 {
1924 dvcman_free(drdynvc, drdynvc->channel_mgr);
1925 drdynvc->channel_mgr = NULL;
1926 }
1927 drdynvc->InitHandle = 0;
1928 free(drdynvc->context);
1929 free(drdynvc);
1930 return CHANNEL_RC_OK;
1931}
1932
1933static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1934{
1935 UINT error = CHANNEL_RC_OK;
1936 DVCMAN* dvcman = NULL;
1937
1938 if (!drdynvc)
1939 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1940
1941 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1942
1943 if (!dvcman)
1944 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1945
1946 ArrayList_Lock(dvcman->plugins);
1947 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1948 {
1949 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1950
1951 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1952 if (error != CHANNEL_RC_OK)
1953 {
1954 WLog_Print(drdynvc->log, WLOG_ERROR, "Attach failed with error %" PRIu32 "!", error);
1955 goto fail;
1956 }
1957 }
1958
1959fail:
1960 ArrayList_Unlock(dvcman->plugins);
1961 return error;
1962}
1963
1964static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1965{
1966 UINT error = CHANNEL_RC_OK;
1967 DVCMAN* dvcman = NULL;
1968
1969 if (!drdynvc)
1970 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1971
1972 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1973
1974 if (!dvcman)
1975 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1976
1977 ArrayList_Lock(dvcman->plugins);
1978 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1979 {
1980 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1981
1982 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1983 if (error != CHANNEL_RC_OK)
1984 {
1985 WLog_Print(drdynvc->log, WLOG_ERROR, "Detach failed with error %" PRIu32 "!", error);
1986 goto fail;
1987 }
1988 }
1989
1990fail:
1991 ArrayList_Unlock(dvcman->plugins);
1992
1993 return error;
1994}
1995
1996static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1997 UINT event, LPVOID pData,
1998 UINT dataLength)
1999{
2000 UINT error = CHANNEL_RC_OK;
2001 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
2002
2003 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
2004 {
2005 WLog_ERR(TAG, "drdynvc_virtual_channel_init_event: error no match");
2006 return;
2007 }
2008
2009 switch (event)
2010 {
2011 case CHANNEL_EVENT_INITIALIZED:
2012 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
2013 break;
2014 case CHANNEL_EVENT_CONNECTED:
2015 if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
2016 WLog_Print(drdynvc->log, WLOG_ERROR,
2017 "drdynvc_virtual_channel_event_connected failed with error %" PRIu32 "",
2018 error);
2019
2020 break;
2021
2022 case CHANNEL_EVENT_DISCONNECTED:
2023 if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
2024 WLog_Print(drdynvc->log, WLOG_ERROR,
2025 "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
2026 "",
2027 error);
2028
2029 break;
2030
2031 case CHANNEL_EVENT_TERMINATED:
2032 if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
2033 WLog_Print(drdynvc->log, WLOG_ERROR,
2034 "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32 "",
2035 error);
2036
2037 break;
2038
2039 case CHANNEL_EVENT_ATTACHED:
2040 if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
2041 WLog_Print(drdynvc->log, WLOG_ERROR,
2042 "drdynvc_virtual_channel_event_attached failed with error %" PRIu32 "",
2043 error);
2044
2045 break;
2046
2047 case CHANNEL_EVENT_DETACHED:
2048 if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
2049 WLog_Print(drdynvc->log, WLOG_ERROR,
2050 "drdynvc_virtual_channel_event_detached failed with error %" PRIu32 "",
2051 error);
2052
2053 break;
2054
2055 default:
2056 break;
2057 }
2058
2059 if (error && drdynvc->rdpcontext)
2060 setChannelError(drdynvc->rdpcontext, error,
2061 "drdynvc_virtual_channel_init_event_ex reported an error");
2062}
2063
2068static int drdynvc_get_version(DrdynvcClientContext* context)
2069{
2070 WINPR_ASSERT(context);
2071 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
2072 WINPR_ASSERT(drdynvc);
2073 return drdynvc->version;
2074}
2075
2076/* drdynvc is always built-in */
2077#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
2078
2079FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2080 PVOID pInitHandle))
2081{
2082 UINT rc = 0;
2083 drdynvcPlugin* drdynvc = NULL;
2084 DrdynvcClientContext* context = NULL;
2085 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = NULL;
2086 drdynvc = (drdynvcPlugin*)calloc(1, sizeof(drdynvcPlugin));
2087
2088 WINPR_ASSERT(pEntryPoints);
2089 if (!drdynvc)
2090 {
2091 WLog_ERR(TAG, "calloc failed!");
2092 return FALSE;
2093 }
2094
2095 drdynvc->channelDef.options =
2096 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2097 (void)sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name),
2098 DRDYNVC_SVC_CHANNEL_NAME);
2099 drdynvc->state = DRDYNVC_STATE_INITIAL;
2100 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2101
2102 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2103 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2104 {
2105 context = (DrdynvcClientContext*)calloc(1, sizeof(DrdynvcClientContext));
2106
2107 if (!context)
2108 {
2109 WLog_Print(drdynvc->log, WLOG_ERROR, "calloc failed!");
2110 free(drdynvc);
2111 return FALSE;
2112 }
2113
2114 context->handle = (void*)drdynvc;
2115 context->custom = NULL;
2116 drdynvc->context = context;
2117 context->GetVersion = drdynvc_get_version;
2118 drdynvc->rdpcontext = pEntryPointsEx->context;
2119 if (!freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2120 FreeRDP_TransportDumpReplay) &&
2121 !freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2122 FreeRDP_SynchronousDynamicChannels))
2123 drdynvc->async = TRUE;
2124 }
2125
2126 drdynvc->log = WLog_Get(TAG);
2127 WLog_Print(drdynvc->log, WLOG_DEBUG, "VirtualChannelEntryEx");
2128 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2129 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
2130 drdynvc->InitHandle = pInitHandle;
2131
2132 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelInitEx);
2133 rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
2134 drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2135 drdynvc_virtual_channel_init_event_ex);
2136
2137 if (CHANNEL_RC_OK != rc)
2138 {
2139 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
2140 WTSErrorToString(rc), rc);
2141 free(drdynvc->context);
2142 free(drdynvc);
2143 return FALSE;
2144 }
2145
2146 drdynvc->channelEntryPoints.pInterface = context;
2147 return TRUE;
2148}
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