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 {
510 IWTSVirtualChannelCallback* cb = channel->channel_callback;
511 if (cb)
512 {
513 check_open_close_receive(channel);
514 IFCALL(cb->OnClose, cb);
515 }
516 }
517
518 channel->channel_callback = NULL;
519
520 if (channel->dvcman && channel->dvcman->drdynvc)
521 {
522 if (context)
523 {
524 IFCALLRET(context->OnChannelDisconnected, error, context, channel->channel_name,
525 channel->pInterface);
526 }
527 }
528
529 if (!fromHashTableFn)
530 dvcman_channel_unref(channel);
531 break;
532 case DVC_CHANNEL_CLOSED:
533 break;
534 default:
535 break;
536 }
537
538 return error;
539}
540
541static DVCMAN_CHANNEL* dvcman_channel_new(WINPR_ATTR_UNUSED drdynvcPlugin* drdynvc,
542 IWTSVirtualChannelManager* pChannelMgr, UINT32 ChannelId,
543 const char* ChannelName)
544{
545 DVCMAN_CHANNEL* channel = NULL;
546
547 WINPR_ASSERT(drdynvc);
548 WINPR_ASSERT(pChannelMgr);
549 channel = (DVCMAN_CHANNEL*)calloc(1, sizeof(DVCMAN_CHANNEL));
550
551 if (!channel)
552 return NULL;
553
554 channel->dvcman = (DVCMAN*)pChannelMgr;
555 channel->channel_id = ChannelId;
556 channel->refCounter = 1;
557 channel->state = DVC_CHANNEL_INIT;
558 channel->channel_name = _strdup(ChannelName);
559 if (!channel->channel_name)
560 goto fail;
561
562 channel->decompressor = zgfx_context_new(FALSE);
563 if (!channel->decompressor)
564 goto fail;
565
566 if (!InitializeCriticalSectionEx(&(channel->lock), 0, 0))
567 goto fail;
568
569 return channel;
570fail:
571 dvcman_channel_free(channel);
572 return NULL;
573}
574
575static void dvcman_clear(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
576{
577 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
578
579 WINPR_ASSERT(dvcman);
580 WINPR_UNUSED(drdynvc);
581
582 HashTable_Clear(dvcman->channelsById);
583 ArrayList_Clear(dvcman->plugins);
584 ArrayList_Clear(dvcman->plugin_names);
585 HashTable_Clear(dvcman->listeners);
586}
587static void dvcman_free(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
588{
589 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
590
591 WINPR_ASSERT(dvcman);
592 WINPR_UNUSED(drdynvc);
593
594 HashTable_Free(dvcman->channelsById);
595 ArrayList_Free(dvcman->plugins);
596 ArrayList_Free(dvcman->plugin_names);
597 HashTable_Free(dvcman->listeners);
598
599 StreamPool_Free(dvcman->pool);
600 free(dvcman);
601}
602
608static UINT dvcman_init(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr)
609{
610 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
611 UINT error = CHANNEL_RC_OK;
612
613 WINPR_ASSERT(dvcman);
614 ArrayList_Lock(dvcman->plugins);
615 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
616 {
617 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
618
619 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Initialize, pPlugin, pChannelMgr);
620 if (error != CHANNEL_RC_OK)
621 {
622 WLog_Print(drdynvc->log, WLOG_ERROR, "Initialize failed with error %" PRIu32 "!",
623 error);
624 goto fail;
625 }
626 }
627
628fail:
629 ArrayList_Unlock(dvcman->plugins);
630 return error;
631}
632
638static UINT dvcman_write_channel(IWTSVirtualChannel* pChannel, ULONG cbSize, const BYTE* pBuffer,
639 void* pReserved)
640{
641 BOOL close = FALSE;
642 UINT status = 0;
643 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
644
645 WINPR_UNUSED(pReserved);
646 if (!channel || !channel->dvcman)
647 return CHANNEL_RC_BAD_CHANNEL;
648
649 EnterCriticalSection(&(channel->lock));
650 status =
651 drdynvc_write_data(channel->dvcman->drdynvc, channel->channel_id, pBuffer, cbSize, &close);
652 LeaveCriticalSection(&(channel->lock));
653 /* Close delayed, it removes the channel struct */
654 if (close)
655 dvcman_channel_close(channel, FALSE, FALSE);
656
657 return status;
658}
659
665static UINT dvcman_close_channel_iface(IWTSVirtualChannel* pChannel)
666{
667 DVCMAN_CHANNEL* channel = (DVCMAN_CHANNEL*)pChannel;
668
669 if (!channel)
670 return CHANNEL_RC_BAD_CHANNEL;
671
672 WLog_DBG(TAG, "close_channel_iface: id=%" PRIu32 "", channel->channel_id);
673 return dvcman_channel_close(channel, FALSE, FALSE);
674}
675
681static DVCMAN_CHANNEL* dvcman_create_channel(drdynvcPlugin* drdynvc,
682 IWTSVirtualChannelManager* pChannelMgr,
683 UINT32 ChannelId, const char* ChannelName, UINT* res)
684{
685 BOOL bAccept = 0;
686 DVCMAN_CHANNEL* channel = NULL;
687 DrdynvcClientContext* context = NULL;
688 DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
689 DVCMAN_LISTENER* listener = NULL;
690 IWTSVirtualChannelCallback* pCallback = NULL;
691
692 WINPR_ASSERT(dvcman);
693 WINPR_ASSERT(res);
694
695 HashTable_Lock(dvcman->listeners);
696 listener = (DVCMAN_LISTENER*)HashTable_GetItemValue(dvcman->listeners, ChannelName);
697 if (!listener)
698 {
699 *res = ERROR_NOT_FOUND;
700 goto out;
701 }
702
703 channel = dvcman_get_channel_by_id(pChannelMgr, ChannelId, FALSE);
704 if (channel)
705 {
706 switch (channel->state)
707 {
708 case DVC_CHANNEL_RUNNING:
709 WLog_Print(drdynvc->log, WLOG_ERROR,
710 "Protocol error: Duplicated ChannelId %" PRIu32 " (%s)!", ChannelId,
711 ChannelName);
712 *res = CHANNEL_RC_ALREADY_OPEN;
713 goto out;
714
715 case DVC_CHANNEL_CLOSED:
716 case DVC_CHANNEL_INIT:
717 default:
718 {
719 WLog_Print(drdynvc->log, WLOG_ERROR, "not expecting a createChannel from state %s",
720 channel_state2str(channel->state));
721 *res = CHANNEL_RC_INITIALIZATION_ERROR;
722 goto out;
723 }
724 }
725 }
726 else
727 {
728 if (!(channel = dvcman_channel_new(drdynvc, pChannelMgr, ChannelId, ChannelName)))
729 {
730 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_channel_new failed!");
731 *res = CHANNEL_RC_NO_MEMORY;
732 goto out;
733 }
734 }
735
736 if (!HashTable_Insert(dvcman->channelsById, &channel->channel_id, channel))
737 {
738 WLog_Print(drdynvc->log, WLOG_ERROR, "unable to register channel in our channel list");
739 *res = ERROR_INTERNAL_ERROR;
740 dvcman_channel_free(channel);
741 channel = NULL;
742 goto out;
743 }
744
745 channel->iface.Write = dvcman_write_channel;
746 channel->iface.Close = dvcman_close_channel_iface;
747 bAccept = TRUE;
748
749 *res = listener->listener_callback->OnNewChannelConnection(
750 listener->listener_callback, &channel->iface, NULL, &bAccept, &pCallback);
751
752 if (*res != CHANNEL_RC_OK)
753 {
754 WLog_Print(drdynvc->log, WLOG_ERROR,
755 "OnNewChannelConnection failed with error %" PRIu32 "!", *res);
756 *res = ERROR_INTERNAL_ERROR;
757 dvcman_channel_unref(channel);
758 goto out;
759 }
760
761 if (!bAccept)
762 {
763 WLog_Print(drdynvc->log, WLOG_ERROR, "OnNewChannelConnection returned with bAccept FALSE!");
764 *res = ERROR_INTERNAL_ERROR;
765 dvcman_channel_unref(channel);
766 channel = NULL;
767 goto out;
768 }
769
770 WLog_Print(drdynvc->log, WLOG_DEBUG, "listener %s created new channel %" PRIu32 "",
771 listener->channel_name, channel->channel_id);
772 channel->state = DVC_CHANNEL_RUNNING;
773 channel->channel_callback = pCallback;
774 channel->pInterface = listener->iface.pInterface;
775 context = dvcman->drdynvc->context;
776
777 IFCALLRET(context->OnChannelConnected, *res, context, ChannelName, listener->iface.pInterface);
778 if (*res != CHANNEL_RC_OK)
779 {
780 WLog_Print(drdynvc->log, WLOG_ERROR,
781 "context.OnChannelConnected failed with error %" PRIu32 "", *res);
782 }
783
784out:
785 HashTable_Unlock(dvcman->listeners);
786
787 return channel;
788}
789
795static UINT dvcman_open_channel(drdynvcPlugin* drdynvc, DVCMAN_CHANNEL* channel)
796{
797 IWTSVirtualChannelCallback* pCallback = NULL;
798 UINT error = CHANNEL_RC_OK;
799
800 WINPR_ASSERT(drdynvc);
801 WINPR_ASSERT(channel);
802 if (channel->state == DVC_CHANNEL_RUNNING)
803 {
804 pCallback = channel->channel_callback;
805
806 if (pCallback->OnOpen)
807 {
808 check_open_close_receive(channel);
809 error = pCallback->OnOpen(pCallback);
810 if (error)
811 {
812 WLog_Print(drdynvc->log, WLOG_ERROR, "OnOpen failed with error %" PRIu32 "!",
813 error);
814 goto out;
815 }
816 }
817
818 WLog_Print(drdynvc->log, WLOG_DEBUG, "open_channel: ChannelId %" PRIu32 "",
819 channel->channel_id);
820 }
821
822out:
823 return error;
824}
825
831static UINT dvcman_receive_channel_data_first(DVCMAN_CHANNEL* channel, UINT32 length)
832{
833 WINPR_ASSERT(channel);
834 WINPR_ASSERT(channel->dvcman);
835 if (channel->dvc_data)
836 Stream_Release(channel->dvc_data);
837
838 channel->dvc_data = StreamPool_Take(channel->dvcman->pool, length);
839
840 if (!channel->dvc_data)
841 {
842 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
843 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
844 return CHANNEL_RC_NO_MEMORY;
845 }
846
847 channel->dvc_data_length = length;
848 return CHANNEL_RC_OK;
849}
850
856static UINT dvcman_receive_channel_data(DVCMAN_CHANNEL* channel, wStream* data,
857 WINPR_ATTR_UNUSED UINT32 ThreadingFlags)
858{
859 UINT status = CHANNEL_RC_OK;
860 size_t dataSize = Stream_GetRemainingLength(data);
861
862 WINPR_ASSERT(channel);
863 WINPR_ASSERT(channel->dvcman);
864 if (channel->dvc_data)
865 {
866 drdynvcPlugin* drdynvc = channel->dvcman->drdynvc;
867
868 /* Fragmented data */
869 if (Stream_GetPosition(channel->dvc_data) + dataSize > channel->dvc_data_length)
870 {
871 WLog_Print(drdynvc->log, WLOG_ERROR, "data exceeding declared length!");
872 Stream_Release(channel->dvc_data);
873 channel->dvc_data = NULL;
874 status = ERROR_INVALID_DATA;
875 goto out;
876 }
877
878 Stream_Copy(data, channel->dvc_data, dataSize);
879
880 if (Stream_GetPosition(channel->dvc_data) >= channel->dvc_data_length)
881 {
882 Stream_SealLength(channel->dvc_data);
883 Stream_SetPosition(channel->dvc_data, 0);
884
885 status = dvcman_call_on_receive(channel, channel->dvc_data);
886 Stream_Release(channel->dvc_data);
887 channel->dvc_data = NULL;
888 }
889 }
890 else
891 status = dvcman_call_on_receive(channel, data);
892
893out:
894 return status;
895}
896
897static UINT8 drdynvc_write_variable_uint(wStream* s, UINT32 val)
898{
899 UINT8 cb = 0;
900
901 if (val <= 0xFF)
902 {
903 cb = 0;
904 Stream_Write_UINT8(s, (UINT8)val);
905 }
906 else if (val <= 0xFFFF)
907 {
908 cb = 1;
909 Stream_Write_UINT16(s, (UINT16)val);
910 }
911 else
912 {
913 cb = 2;
914 Stream_Write_UINT32(s, val);
915 }
916
917 return cb;
918}
919
925static UINT drdynvc_send(drdynvcPlugin* drdynvc, wStream* s)
926{
927 UINT status = 0;
928
929 if (!drdynvc)
930 status = CHANNEL_RC_BAD_CHANNEL_HANDLE;
931 else
932 {
933 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelWriteEx);
934 status = drdynvc->channelEntryPoints.pVirtualChannelWriteEx(
935 drdynvc->InitHandle, drdynvc->OpenHandle, Stream_Buffer(s),
936 (UINT32)Stream_GetPosition(s), s);
937 }
938
939 switch (status)
940 {
941 case CHANNEL_RC_OK:
942 return CHANNEL_RC_OK;
943
944 case CHANNEL_RC_NOT_CONNECTED:
945 Stream_Release(s);
946 return CHANNEL_RC_OK;
947
948 case CHANNEL_RC_BAD_CHANNEL_HANDLE:
949 Stream_Release(s);
950 WLog_ERR(TAG, "VirtualChannelWriteEx failed with CHANNEL_RC_BAD_CHANNEL_HANDLE");
951 return status;
952
953 default:
954 Stream_Release(s);
955 WLog_Print(drdynvc->log, WLOG_ERROR,
956 "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
957 WTSErrorToString(status), status);
958 return status;
959 }
960}
961
967static UINT drdynvc_write_data(drdynvcPlugin* drdynvc, UINT32 ChannelId, const BYTE* data,
968 UINT32 dataSize, BOOL* close)
969{
970 wStream* data_out = NULL;
971 size_t pos = 0;
972 UINT8 cbChId = 0;
973 UINT8 cbLen = 0;
974 UINT status = CHANNEL_RC_BAD_INIT_HANDLE;
975 DVCMAN* dvcman = NULL;
976
977 if (!drdynvc)
978 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
979
980 dvcman = (DVCMAN*)drdynvc->channel_mgr;
981 WINPR_ASSERT(dvcman);
982
983 WLog_Print(drdynvc->log, WLOG_TRACE, "write_data: ChannelId=%" PRIu32 " size=%" PRIu32 "",
984 ChannelId, dataSize);
985 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
986
987 if (!data_out)
988 {
989 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
990 return CHANNEL_RC_NO_MEMORY;
991 }
992
993 Stream_SetPosition(data_out, 1);
994 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
995 pos = Stream_GetPosition(data_out);
996
997 if (dataSize == 0)
998 {
999 /* TODO: shall treat that case with write(0) that do a close */
1000 *close = TRUE;
1001 Stream_Release(data_out);
1002 }
1003 else if (dataSize <= CHANNEL_CHUNK_LENGTH - pos)
1004 {
1005 Stream_SetPosition(data_out, 0);
1006 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1007 Stream_SetPosition(data_out, pos);
1008 Stream_Write(data_out, data, dataSize);
1009 status = drdynvc_send(drdynvc, data_out);
1010 }
1011 else
1012 {
1013 /* Fragment the data */
1014 cbLen = drdynvc_write_variable_uint(data_out, dataSize);
1015 pos = Stream_GetPosition(data_out);
1016 Stream_SetPosition(data_out, 0);
1017
1018 const INT32 pdu = (DATA_FIRST_PDU << 4) | cbChId | (cbLen << 2);
1019 Stream_Write_UINT8(data_out, WINPR_ASSERTING_INT_CAST(UINT8, pdu));
1020 Stream_SetPosition(data_out, pos);
1021
1022 {
1023 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1024 const uint32_t chunkLength =
1025 CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1026 Stream_Write(data_out, data, chunkLength);
1027
1028 data += chunkLength;
1029 dataSize -= chunkLength;
1030 }
1031 status = drdynvc_send(drdynvc, data_out);
1032
1033 while (status == CHANNEL_RC_OK && dataSize > 0)
1034 {
1035 data_out = StreamPool_Take(dvcman->pool, CHANNEL_CHUNK_LENGTH);
1036
1037 if (!data_out)
1038 {
1039 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1040 return CHANNEL_RC_NO_MEMORY;
1041 }
1042
1043 Stream_SetPosition(data_out, 1);
1044 cbChId = drdynvc_write_variable_uint(data_out, ChannelId);
1045 pos = Stream_GetPosition(data_out);
1046 Stream_SetPosition(data_out, 0);
1047 Stream_Write_UINT8(data_out, (DATA_PDU << 4) | cbChId);
1048 Stream_SetPosition(data_out, pos);
1049
1050 uint32_t chunkLength = dataSize;
1051
1052 WINPR_ASSERT(pos <= CHANNEL_CHUNK_LENGTH);
1053 if (chunkLength > CHANNEL_CHUNK_LENGTH - pos)
1054 chunkLength = CHANNEL_CHUNK_LENGTH - WINPR_ASSERTING_INT_CAST(uint32_t, pos);
1055
1056 Stream_Write(data_out, data, chunkLength);
1057 data += chunkLength;
1058 dataSize -= chunkLength;
1059 status = drdynvc_send(drdynvc, data_out);
1060 }
1061 }
1062
1063 if (status != CHANNEL_RC_OK)
1064 {
1065 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1066 WTSErrorToString(status), status);
1067 return status;
1068 }
1069
1070 return CHANNEL_RC_OK;
1071}
1072
1078static UINT drdynvc_send_capability_response(drdynvcPlugin* drdynvc)
1079{
1080 UINT status = 0;
1081 wStream* s = NULL;
1082 DVCMAN* dvcman = NULL;
1083
1084 if (!drdynvc)
1085 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1086
1087 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1088 WINPR_ASSERT(dvcman);
1089
1090 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_response");
1091 s = StreamPool_Take(dvcman->pool, 4);
1092
1093 if (!s)
1094 {
1095 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_Ndrdynvc_write_variable_uintew failed!");
1096 return CHANNEL_RC_NO_MEMORY;
1097 }
1098
1099 Stream_Write_UINT16(s, 0x0050); /* Cmd+Sp+cbChId+Pad. Note: MSTSC sends 0x005c */
1100 Stream_Write_UINT16(s, drdynvc->version);
1101 status = drdynvc_send(drdynvc, s);
1102
1103 if (status != CHANNEL_RC_OK)
1104 {
1105 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1106 WTSErrorToString(status), status);
1107 }
1108
1109 return status;
1110}
1111
1117static UINT drdynvc_process_capability_request(drdynvcPlugin* drdynvc, int Sp, int cbChId,
1118 wStream* s)
1119{
1120 UINT status = 0;
1121
1122 if (!drdynvc)
1123 return CHANNEL_RC_BAD_INIT_HANDLE;
1124
1125 if (!Stream_CheckAndLogRequiredLength(TAG, s, 3))
1126 return ERROR_INVALID_DATA;
1127
1128 WLog_Print(drdynvc->log, WLOG_TRACE, "capability_request Sp=%d cbChId=%d", Sp, cbChId);
1129 Stream_Seek(s, 1); /* pad */
1130 Stream_Read_UINT16(s, drdynvc->version);
1131
1132 /* RDP8 servers offer version 3, though Microsoft forgot to document it
1133 * in their early documents. It behaves the same as version 2.
1134 */
1135 if ((drdynvc->version == 2) || (drdynvc->version == 3))
1136 {
1137 if (!Stream_CheckAndLogRequiredLength(TAG, s, 8))
1138 return ERROR_INVALID_DATA;
1139
1140 Stream_Read_UINT16(s, drdynvc->PriorityCharge0);
1141 Stream_Read_UINT16(s, drdynvc->PriorityCharge1);
1142 Stream_Read_UINT16(s, drdynvc->PriorityCharge2);
1143 Stream_Read_UINT16(s, drdynvc->PriorityCharge3);
1144 }
1145
1146 status = drdynvc_send_capability_response(drdynvc);
1147 drdynvc->state = DRDYNVC_STATE_READY;
1148 return status;
1149}
1150
1151static UINT32 drdynvc_cblen_to_bytes(int cbLen)
1152{
1153 switch (cbLen)
1154 {
1155 case 0:
1156 return 1;
1157
1158 case 1:
1159 return 2;
1160
1161 default:
1162 return 4;
1163 }
1164}
1165
1166static UINT32 drdynvc_read_variable_uint(wStream* s, int cbLen)
1167{
1168 UINT32 val = 0;
1169
1170 switch (cbLen)
1171 {
1172 case 0:
1173 Stream_Read_UINT8(s, val);
1174 break;
1175
1176 case 1:
1177 Stream_Read_UINT16(s, val);
1178 break;
1179
1180 default:
1181 Stream_Read_UINT32(s, val);
1182 break;
1183 }
1184
1185 return val;
1186}
1187
1193static UINT drdynvc_process_create_request(drdynvcPlugin* drdynvc, UINT8 Sp, UINT8 cbChId,
1194 wStream* s)
1195{
1196 UINT status = 0;
1197 wStream* data_out = NULL;
1198 UINT channel_status = 0;
1199 DVCMAN* dvcman = NULL;
1200 DVCMAN_CHANNEL* channel = NULL;
1201 INT32 retStatus = 0;
1202
1203 WINPR_UNUSED(Sp);
1204 if (!drdynvc)
1205 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1206
1207 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1208 WINPR_ASSERT(dvcman);
1209
1210 if (drdynvc->state == DRDYNVC_STATE_CAPABILITIES)
1211 {
1217 drdynvc->version = 3;
1218
1219 if ((status = drdynvc_send_capability_response(drdynvc)))
1220 {
1221 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_send_capability_response failed!");
1222 return status;
1223 }
1224
1225 drdynvc->state = DRDYNVC_STATE_READY;
1226 }
1227
1228 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1229 return ERROR_INVALID_DATA;
1230
1231 const UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1232 const size_t pos = Stream_GetPosition(s);
1233 const char* name = Stream_ConstPointer(s);
1234 const size_t length = Stream_GetRemainingLength(s);
1235
1236 if (strnlen(name, length) >= length)
1237 return ERROR_INVALID_DATA;
1238
1239 WLog_Print(drdynvc->log, WLOG_DEBUG,
1240 "process_create_request: ChannelId=%" PRIu32 " ChannelName=%s", ChannelId, name);
1241
1242 data_out = StreamPool_Take(dvcman->pool, pos + 4);
1243 if (!data_out)
1244 {
1245 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1246 return CHANNEL_RC_NO_MEMORY;
1247 }
1248
1249 Stream_Write_UINT8(data_out, (CREATE_REQUEST_PDU << 4) | cbChId);
1250 Stream_SetPosition(s, 1);
1251 Stream_Copy(s, data_out, pos - 1);
1252
1253 channel =
1254 dvcman_create_channel(drdynvc, drdynvc->channel_mgr, ChannelId, name, &channel_status);
1255 switch (channel_status)
1256 {
1257 case CHANNEL_RC_OK:
1258 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel created");
1259 retStatus = 0;
1260 break;
1261 case CHANNEL_RC_NO_MEMORY:
1262 WLog_Print(drdynvc->log, WLOG_DEBUG, "not enough memory for channel creation");
1263 retStatus = STATUS_NO_MEMORY;
1264 break;
1265 case ERROR_NOT_FOUND:
1266 WLog_Print(drdynvc->log, WLOG_DEBUG, "no listener for '%s'", name);
1267 retStatus = STATUS_NOT_FOUND; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1268 break;
1269 default:
1270 WLog_Print(drdynvc->log, WLOG_DEBUG, "channel creation error");
1271 retStatus = STATUS_UNSUCCESSFUL; /* same code used by mstsc, STATUS_UNSUCCESSFUL */
1272 break;
1273 }
1274 Stream_Write_INT32(data_out, retStatus);
1275
1276 status = drdynvc_send(drdynvc, data_out);
1277 if (status != CHANNEL_RC_OK)
1278 {
1279 WLog_Print(drdynvc->log, WLOG_ERROR, "VirtualChannelWriteEx failed with %s [%08" PRIX32 "]",
1280 WTSErrorToString(status), status);
1281 dvcman_channel_unref(channel);
1282 return status;
1283 }
1284
1285 if (channel_status == CHANNEL_RC_OK)
1286 {
1287 if ((status = dvcman_open_channel(drdynvc, channel)))
1288 {
1289 WLog_Print(drdynvc->log, WLOG_ERROR,
1290 "dvcman_open_channel failed with error %" PRIu32 "!", status);
1291 return status;
1292 }
1293 }
1294
1295 return status;
1296}
1297
1303static UINT drdynvc_process_data_first(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1304 BOOL compressed, UINT32 ThreadingFlags)
1305{
1306 WINPR_ASSERT(drdynvc);
1307 if (!Stream_CheckAndLogRequiredLength(
1308 TAG, s, drdynvc_cblen_to_bytes(cbChId) + drdynvc_cblen_to_bytes(Sp)))
1309 return ERROR_INVALID_DATA;
1310
1311 UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1312 UINT32 Length = drdynvc_read_variable_uint(s, Sp);
1313 WLog_Print(drdynvc->log, WLOG_TRACE,
1314 "process_data_first: Sp=%d cbChId=%d, ChannelId=%" PRIu32 " Length=%" PRIu32 "", Sp,
1315 cbChId, ChannelId, Length);
1316
1317 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1318 if (!channel)
1319 {
1325 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
1326 return CHANNEL_RC_OK;
1327 }
1328
1329 UINT status = CHANNEL_RC_OK;
1330 BOOL shouldFree = FALSE;
1331 if (channel->state != DVC_CHANNEL_RUNNING)
1332 goto out;
1333
1334 if (compressed)
1335 {
1336 BYTE* data = NULL;
1337 UINT32 dataSize = 0;
1338 if (zgfx_decompress(channel->decompressor, Stream_Pointer(s),
1339 WINPR_ASSERTING_INT_CAST(UINT32, Stream_GetRemainingLength(s)), &data,
1340 &dataSize, 0) < 0)
1341 {
1342 status = ERROR_INVALID_DATA;
1343 WLog_Print(drdynvc->log, WLOG_ERROR, "error de-compressing first packet");
1344 goto out;
1345 }
1346
1347 s = Stream_New(data, dataSize);
1348 if (!s)
1349 {
1350 status = CHANNEL_RC_NO_MEMORY;
1351 WLog_Print(drdynvc->log, WLOG_ERROR, "error allocating new Stream(len=%" PRIu32 ")",
1352 dataSize);
1353 free(data);
1354 goto out;
1355 }
1356 shouldFree = TRUE;
1357 }
1358
1359 status = dvcman_receive_channel_data_first(channel, Length);
1360
1361 if (status == CHANNEL_RC_OK)
1362 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1363
1364 if (status != CHANNEL_RC_OK)
1365 status = dvcman_channel_close(channel, FALSE, FALSE);
1366
1367out:
1368 if (shouldFree)
1369 Stream_Free(s, TRUE);
1370 dvcman_channel_unref(channel);
1371 return status;
1372}
1373
1379static UINT drdynvc_process_data(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s,
1380 BOOL compressed, UINT32 ThreadingFlags)
1381{
1382 WINPR_ASSERT(drdynvc);
1383 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1384 return ERROR_INVALID_DATA;
1385
1386 UINT32 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1387 WLog_Print(drdynvc->log, WLOG_TRACE, "process_data: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp,
1388 cbChId, ChannelId);
1389
1390 DVCMAN_CHANNEL* channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1391 if (!channel)
1392 {
1398 WLog_Print(drdynvc->log, WLOG_ERROR, "ChannelId %" PRIu32 " not found!", ChannelId);
1399 return CHANNEL_RC_OK;
1400 }
1401
1402 BOOL shouldFree = FALSE;
1403 UINT status = CHANNEL_RC_OK;
1404 if (channel->state != DVC_CHANNEL_RUNNING)
1405 goto out;
1406
1407 if (compressed)
1408 {
1409 BYTE* data = NULL;
1410 UINT32 dataSize = 0;
1411
1412 if (zgfx_decompress(channel->decompressor, Stream_Pointer(s),
1413 WINPR_ASSERTING_INT_CAST(UINT32, Stream_GetRemainingLength(s)), &data,
1414 &dataSize, 0) < 0)
1415 {
1416 status = ERROR_INVALID_DATA;
1417 WLog_Print(drdynvc->log, WLOG_ERROR, "error de-compressing data packet");
1418 goto out;
1419 }
1420
1421 s = Stream_New(data, dataSize);
1422 if (!s)
1423 {
1424 status = CHANNEL_RC_NO_MEMORY;
1425 WLog_Print(drdynvc->log, WLOG_ERROR, "error allocating new Stream(len=%" PRIu32 ")",
1426 dataSize);
1427 free(data);
1428 goto out;
1429 }
1430 shouldFree = TRUE;
1431 }
1432
1433 status = dvcman_receive_channel_data(channel, s, ThreadingFlags);
1434 if (status != CHANNEL_RC_OK)
1435 status = dvcman_channel_close(channel, FALSE, FALSE);
1436
1437out:
1438 if (shouldFree)
1439 Stream_Free(s, TRUE);
1440 dvcman_channel_unref(channel);
1441 return status;
1442}
1443
1449static UINT drdynvc_process_close_request(drdynvcPlugin* drdynvc, int Sp, int cbChId, wStream* s)
1450{
1451 UINT32 ChannelId = 0;
1452 DVCMAN_CHANNEL* channel = NULL;
1453
1454 WINPR_ASSERT(drdynvc);
1455 if (!Stream_CheckAndLogRequiredLength(TAG, s, drdynvc_cblen_to_bytes(cbChId)))
1456 return ERROR_INVALID_DATA;
1457
1458 ChannelId = drdynvc_read_variable_uint(s, cbChId);
1459 WLog_Print(drdynvc->log, WLOG_DEBUG,
1460 "process_close_request: Sp=%d cbChId=%d, ChannelId=%" PRIu32 "", Sp, cbChId,
1461 ChannelId);
1462
1463 channel = dvcman_get_channel_by_id(drdynvc->channel_mgr, ChannelId, TRUE);
1464 if (!channel)
1465 {
1466 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_close_request channel %" PRIu32 " not present",
1467 ChannelId);
1468 return CHANNEL_RC_OK;
1469 }
1470
1471 dvcman_channel_close(channel, TRUE, FALSE);
1472 dvcman_channel_unref(channel);
1473 return CHANNEL_RC_OK;
1474}
1475
1481static UINT drdynvc_order_recv(drdynvcPlugin* drdynvc, wStream* s, UINT32 ThreadingFlags)
1482{
1483 WINPR_ASSERT(drdynvc);
1484 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
1485 return ERROR_INVALID_DATA;
1486
1487 UINT8 value = Stream_Get_UINT8(s);
1488 const UINT8 Cmd = (value & 0xf0) >> 4;
1489 const UINT8 Sp = (value & 0x0c) >> 2;
1490 const UINT8 cbChId = (value & 0x03) >> 0;
1491 WLog_Print(drdynvc->log, WLOG_TRACE, "order_recv: Cmd=%s, Sp=%" PRIu8 " cbChId=%" PRIu8,
1492 drdynvc_get_packet_type(Cmd), Sp, cbChId);
1493
1494 switch (Cmd)
1495 {
1496 case CAPABILITY_REQUEST_PDU:
1497 return drdynvc_process_capability_request(drdynvc, Sp, cbChId, s);
1498
1499 case CREATE_REQUEST_PDU:
1500 return drdynvc_process_create_request(drdynvc, Sp, cbChId, s);
1501
1502 case DATA_FIRST_PDU:
1503 case DATA_FIRST_COMPRESSED_PDU:
1504 return drdynvc_process_data_first(drdynvc, Sp, cbChId, s,
1505 (Cmd == DATA_FIRST_COMPRESSED_PDU), ThreadingFlags);
1506
1507 case DATA_PDU:
1508 case DATA_COMPRESSED_PDU:
1509 return drdynvc_process_data(drdynvc, Sp, cbChId, s, (Cmd == DATA_COMPRESSED_PDU),
1510 ThreadingFlags);
1511
1512 case CLOSE_REQUEST_PDU:
1513 return drdynvc_process_close_request(drdynvc, Sp, cbChId, s);
1514
1515 case SOFT_SYNC_RESPONSE_PDU:
1516 WLog_Print(drdynvc->log, WLOG_ERROR,
1517 "not expecting a SOFT_SYNC_RESPONSE_PDU as a client");
1518 return ERROR_INTERNAL_ERROR;
1519
1520 default:
1521 WLog_Print(drdynvc->log, WLOG_ERROR, "unknown drdynvc cmd 0x%x", Cmd);
1522 return ERROR_INTERNAL_ERROR;
1523 }
1524}
1525
1531static UINT drdynvc_virtual_channel_event_data_received(drdynvcPlugin* drdynvc, void* pData,
1532 UINT32 dataLength, UINT32 totalLength,
1533 UINT32 dataFlags)
1534{
1535 wStream* data_in = NULL;
1536
1537 WINPR_ASSERT(drdynvc);
1538 if ((dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
1539 {
1540 return CHANNEL_RC_OK;
1541 }
1542
1543 if (dataFlags & CHANNEL_FLAG_FIRST)
1544 {
1545 DVCMAN* mgr = (DVCMAN*)drdynvc->channel_mgr;
1546 if (drdynvc->data_in)
1547 Stream_Release(drdynvc->data_in);
1548
1549 drdynvc->data_in = StreamPool_Take(mgr->pool, totalLength);
1550 }
1551
1552 if (!(data_in = drdynvc->data_in))
1553 {
1554 WLog_Print(drdynvc->log, WLOG_ERROR, "StreamPool_Take failed!");
1555 return CHANNEL_RC_NO_MEMORY;
1556 }
1557
1558 if (!Stream_EnsureRemainingCapacity(data_in, dataLength))
1559 {
1560 WLog_Print(drdynvc->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
1561 Stream_Release(drdynvc->data_in);
1562 drdynvc->data_in = NULL;
1563 return ERROR_INTERNAL_ERROR;
1564 }
1565
1566 Stream_Write(data_in, pData, dataLength);
1567
1568 if (dataFlags & CHANNEL_FLAG_LAST)
1569 {
1570 const size_t cap = Stream_Capacity(data_in);
1571 const size_t pos = Stream_GetPosition(data_in);
1572 if (cap < pos)
1573 {
1574 WLog_Print(drdynvc->log, WLOG_ERROR, "drdynvc_plugin_process_received: read error");
1575 return ERROR_INVALID_DATA;
1576 }
1577
1578 drdynvc->data_in = NULL;
1579 Stream_SealLength(data_in);
1580 Stream_SetPosition(data_in, 0);
1581
1582 if (drdynvc->async)
1583 {
1584 if (!MessageQueue_Post(drdynvc->queue, NULL, 0, (void*)data_in, NULL))
1585 {
1586 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Post failed!");
1587 return ERROR_INTERNAL_ERROR;
1588 }
1589 }
1590 else
1591 {
1592 UINT error = drdynvc_order_recv(drdynvc, data_in, TRUE);
1593 Stream_Release(data_in);
1594
1595 if (error)
1596 {
1597 WLog_Print(drdynvc->log, WLOG_WARN,
1598 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1599 return error;
1600 }
1601 }
1602 }
1603
1604 return CHANNEL_RC_OK;
1605}
1606
1607static void VCAPITYPE drdynvc_virtual_channel_open_event_ex(LPVOID lpUserParam, DWORD openHandle,
1608 UINT event, LPVOID pData,
1609 UINT32 dataLength, UINT32 totalLength,
1610 UINT32 dataFlags)
1611{
1612 UINT error = CHANNEL_RC_OK;
1613 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
1614
1615 WINPR_ASSERT(drdynvc);
1616 switch (event)
1617 {
1618 case CHANNEL_EVENT_DATA_RECEIVED:
1619 if (!drdynvc || (drdynvc->OpenHandle != openHandle))
1620 {
1621 WLog_ERR(TAG, "drdynvc_virtual_channel_open_event: error no match");
1622 return;
1623 }
1624 if ((error = drdynvc_virtual_channel_event_data_received(drdynvc, pData, dataLength,
1625 totalLength, dataFlags)))
1626 WLog_Print(drdynvc->log, WLOG_ERROR,
1627 "drdynvc_virtual_channel_event_data_received failed with error %" PRIu32
1628 "",
1629 error);
1630
1631 break;
1632
1633 case CHANNEL_EVENT_WRITE_CANCELLED:
1634 case CHANNEL_EVENT_WRITE_COMPLETE:
1635 {
1636 wStream* s = (wStream*)pData;
1637 Stream_Release(s);
1638 }
1639 break;
1640
1641 case CHANNEL_EVENT_USER:
1642 break;
1643 default:
1644 break;
1645 }
1646
1647 if (error && drdynvc && drdynvc->rdpcontext)
1648 setChannelError(drdynvc->rdpcontext, error,
1649 "drdynvc_virtual_channel_open_event reported an error");
1650}
1651
1652static DWORD WINAPI drdynvc_virtual_channel_client_thread(LPVOID arg)
1653{
1654 /* TODO: rewrite this */
1655 wStream* data = NULL;
1656 wMessage message = { 0 };
1657 UINT error = CHANNEL_RC_OK;
1658 drdynvcPlugin* drdynvc = (drdynvcPlugin*)arg;
1659
1660 if (!drdynvc)
1661 {
1662 ExitThread((DWORD)CHANNEL_RC_BAD_CHANNEL_HANDLE);
1663 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1664 }
1665
1666 while (1)
1667 {
1668 if (!MessageQueue_Wait(drdynvc->queue))
1669 {
1670 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Wait failed!");
1671 error = ERROR_INTERNAL_ERROR;
1672 break;
1673 }
1674
1675 if (!MessageQueue_Peek(drdynvc->queue, &message, TRUE))
1676 {
1677 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_Peek failed!");
1678 error = ERROR_INTERNAL_ERROR;
1679 break;
1680 }
1681
1682 if (message.id == WMQ_QUIT)
1683 break;
1684
1685 if (message.id == 0)
1686 {
1687 UINT32 ThreadingFlags = TRUE;
1688 data = (wStream*)message.wParam;
1689
1690 if ((error = drdynvc_order_recv(drdynvc, data, ThreadingFlags)))
1691 {
1692 WLog_Print(drdynvc->log, WLOG_WARN,
1693 "drdynvc_order_recv failed with error %" PRIu32 "!", error);
1694 }
1695
1696 Stream_Release(data);
1697 }
1698 }
1699
1700 {
1701 /* Disconnect remaining dynamic channels that the server did not.
1702 * This is required to properly shut down channels by calling the appropriate
1703 * event handlers. */
1704 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1705
1706 HashTable_Clear(drdynvcMgr->channelsById);
1707 }
1708
1709 if (error && drdynvc->rdpcontext)
1710 setChannelError(drdynvc->rdpcontext, error,
1711 "drdynvc_virtual_channel_client_thread reported an error");
1712
1713 ExitThread((DWORD)error);
1714 return error;
1715}
1716
1717static void drdynvc_queue_object_free(void* obj)
1718{
1719 wStream* s = NULL;
1720 wMessage* msg = (wMessage*)obj;
1721
1722 if (!msg || (msg->id != 0))
1723 return;
1724
1725 s = (wStream*)msg->wParam;
1726
1727 if (s)
1728 Stream_Release(s);
1729}
1730
1731static UINT drdynvc_virtual_channel_event_initialized(drdynvcPlugin* drdynvc, LPVOID pData,
1732 UINT32 dataLength)
1733{
1734 wObject* obj = NULL;
1735 WINPR_UNUSED(pData);
1736 WINPR_UNUSED(dataLength);
1737
1738 if (!drdynvc)
1739 goto error;
1740
1741 drdynvc->queue = MessageQueue_New(NULL);
1742
1743 if (!drdynvc->queue)
1744 {
1745 WLog_Print(drdynvc->log, WLOG_ERROR, "MessageQueue_New failed!");
1746 goto error;
1747 }
1748
1749 obj = MessageQueue_Object(drdynvc->queue);
1750 obj->fnObjectFree = drdynvc_queue_object_free;
1751 drdynvc->channel_mgr = dvcman_new(drdynvc);
1752
1753 if (!drdynvc->channel_mgr)
1754 {
1755 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_new failed!");
1756 goto error;
1757 }
1758
1759 return CHANNEL_RC_OK;
1760error:
1761 return ERROR_INTERNAL_ERROR;
1762}
1763
1769static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVOID pData,
1770 UINT32 dataLength)
1771{
1772 UINT error = 0;
1773 UINT32 status = 0;
1774 rdpSettings* settings = NULL;
1775
1776 WINPR_ASSERT(drdynvc);
1777 WINPR_UNUSED(pData);
1778 WINPR_UNUSED(dataLength);
1779
1780 if (!drdynvc)
1781 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1782
1783 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelOpenEx);
1784 status = drdynvc->channelEntryPoints.pVirtualChannelOpenEx(
1785 drdynvc->InitHandle, &drdynvc->OpenHandle, drdynvc->channelDef.name,
1786 drdynvc_virtual_channel_open_event_ex);
1787
1788 if (status != CHANNEL_RC_OK)
1789 {
1790 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelOpen failed with %s [%08" PRIX32 "]",
1791 WTSErrorToString(status), status);
1792 return status;
1793 }
1794
1795 WINPR_ASSERT(drdynvc->rdpcontext);
1796 settings = drdynvc->rdpcontext->settings;
1797 WINPR_ASSERT(settings);
1798
1799 for (UINT32 index = 0;
1800 index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
1801 {
1802 const ADDIN_ARGV* args =
1803 freerdp_settings_get_pointer_array(settings, FreeRDP_DynamicChannelArray, index);
1804 error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, drdynvc->rdpcontext);
1805
1806 if (CHANNEL_RC_OK != error)
1807 goto error;
1808 }
1809
1810 if ((error = dvcman_init(drdynvc, drdynvc->channel_mgr)))
1811 {
1812 WLog_Print(drdynvc->log, WLOG_ERROR, "dvcman_init failed with error %" PRIu32 "!", error);
1813 goto error;
1814 }
1815
1816 drdynvc->state = DRDYNVC_STATE_CAPABILITIES;
1817
1818 if (drdynvc->async)
1819 {
1820 if (!(drdynvc->thread = CreateThread(NULL, 0, drdynvc_virtual_channel_client_thread,
1821 (void*)drdynvc, 0, NULL)))
1822 {
1823 error = ERROR_INTERNAL_ERROR;
1824 WLog_Print(drdynvc->log, WLOG_ERROR, "CreateThread failed!");
1825 goto error;
1826 }
1827
1828 if (!SetThreadPriority(drdynvc->thread, THREAD_PRIORITY_HIGHEST))
1829 WLog_Print(drdynvc->log, WLOG_WARN, "SetThreadPriority failed, ignoring.");
1830 }
1831
1832error:
1833 return error;
1834}
1835
1841static UINT drdynvc_virtual_channel_event_disconnected(drdynvcPlugin* drdynvc)
1842{
1843 UINT status = 0;
1844
1845 if (!drdynvc)
1846 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1847
1848 if (drdynvc->OpenHandle == 0)
1849 return CHANNEL_RC_OK;
1850
1851 if (drdynvc->queue)
1852 {
1853 if (!MessageQueue_PostQuit(drdynvc->queue, 0))
1854 {
1855 status = GetLastError();
1856 WLog_Print(drdynvc->log, WLOG_ERROR,
1857 "MessageQueue_PostQuit failed with error %" PRIu32 "", status);
1858 return status;
1859 }
1860 }
1861
1862 if (drdynvc->thread)
1863 {
1864 if (WaitForSingleObject(drdynvc->thread, INFINITE) != WAIT_OBJECT_0)
1865 {
1866 status = GetLastError();
1867 WLog_Print(drdynvc->log, WLOG_ERROR,
1868 "WaitForSingleObject failed with error %" PRIu32 "", status);
1869 return status;
1870 }
1871
1872 (void)CloseHandle(drdynvc->thread);
1873 drdynvc->thread = NULL;
1874 }
1875 else
1876 {
1877 {
1878 /* Disconnect remaining dynamic channels that the server did not.
1879 * This is required to properly shut down channels by calling the appropriate
1880 * event handlers. */
1881 DVCMAN* drdynvcMgr = (DVCMAN*)drdynvc->channel_mgr;
1882
1883 HashTable_Clear(drdynvcMgr->channelsById);
1884 }
1885 }
1886
1887 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelCloseEx);
1888 status = drdynvc->channelEntryPoints.pVirtualChannelCloseEx(drdynvc->InitHandle,
1889 drdynvc->OpenHandle);
1890
1891 if (status != CHANNEL_RC_OK)
1892 {
1893 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelClose failed with %s [%08" PRIX32 "]",
1894 WTSErrorToString(status), status);
1895 }
1896
1897 dvcman_clear(drdynvc, drdynvc->channel_mgr);
1898 if (drdynvc->queue)
1899 MessageQueue_Clear(drdynvc->queue);
1900 drdynvc->OpenHandle = 0;
1901
1902 if (drdynvc->data_in)
1903 {
1904 Stream_Release(drdynvc->data_in);
1905 drdynvc->data_in = NULL;
1906 }
1907
1908 return status;
1909}
1910
1916static UINT drdynvc_virtual_channel_event_terminated(drdynvcPlugin* drdynvc)
1917{
1918 if (!drdynvc)
1919 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1920
1921 MessageQueue_Free(drdynvc->queue);
1922 drdynvc->queue = NULL;
1923
1924 if (drdynvc->channel_mgr)
1925 {
1926 dvcman_free(drdynvc, drdynvc->channel_mgr);
1927 drdynvc->channel_mgr = NULL;
1928 }
1929 drdynvc->InitHandle = 0;
1930 free(drdynvc->context);
1931 free(drdynvc);
1932 return CHANNEL_RC_OK;
1933}
1934
1935static UINT drdynvc_virtual_channel_event_attached(drdynvcPlugin* drdynvc)
1936{
1937 UINT error = CHANNEL_RC_OK;
1938 DVCMAN* dvcman = NULL;
1939
1940 if (!drdynvc)
1941 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1942
1943 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1944
1945 if (!dvcman)
1946 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1947
1948 ArrayList_Lock(dvcman->plugins);
1949 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1950 {
1951 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1952
1953 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Attached, pPlugin);
1954 if (error != CHANNEL_RC_OK)
1955 {
1956 WLog_Print(drdynvc->log, WLOG_ERROR, "Attach failed with error %" PRIu32 "!", error);
1957 goto fail;
1958 }
1959 }
1960
1961fail:
1962 ArrayList_Unlock(dvcman->plugins);
1963 return error;
1964}
1965
1966static UINT drdynvc_virtual_channel_event_detached(drdynvcPlugin* drdynvc)
1967{
1968 UINT error = CHANNEL_RC_OK;
1969 DVCMAN* dvcman = NULL;
1970
1971 if (!drdynvc)
1972 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1973
1974 dvcman = (DVCMAN*)drdynvc->channel_mgr;
1975
1976 if (!dvcman)
1977 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1978
1979 ArrayList_Lock(dvcman->plugins);
1980 for (size_t i = 0; i < ArrayList_Count(dvcman->plugins); i++)
1981 {
1982 IWTSPlugin* pPlugin = ArrayList_GetItem(dvcman->plugins, i);
1983
1984 error = IFCALLRESULT(CHANNEL_RC_OK, pPlugin->Detached, pPlugin);
1985 if (error != CHANNEL_RC_OK)
1986 {
1987 WLog_Print(drdynvc->log, WLOG_ERROR, "Detach failed with error %" PRIu32 "!", error);
1988 goto fail;
1989 }
1990 }
1991
1992fail:
1993 ArrayList_Unlock(dvcman->plugins);
1994
1995 return error;
1996}
1997
1998static VOID VCAPITYPE drdynvc_virtual_channel_init_event_ex(LPVOID lpUserParam, LPVOID pInitHandle,
1999 UINT event, LPVOID pData,
2000 UINT dataLength)
2001{
2002 UINT error = CHANNEL_RC_OK;
2003 drdynvcPlugin* drdynvc = (drdynvcPlugin*)lpUserParam;
2004
2005 if (!drdynvc || (drdynvc->InitHandle != pInitHandle))
2006 {
2007 WLog_ERR(TAG, "drdynvc_virtual_channel_init_event: error no match");
2008 return;
2009 }
2010
2011 switch (event)
2012 {
2013 case CHANNEL_EVENT_INITIALIZED:
2014 error = drdynvc_virtual_channel_event_initialized(drdynvc, pData, dataLength);
2015 break;
2016 case CHANNEL_EVENT_CONNECTED:
2017 if ((error = drdynvc_virtual_channel_event_connected(drdynvc, pData, dataLength)))
2018 WLog_Print(drdynvc->log, WLOG_ERROR,
2019 "drdynvc_virtual_channel_event_connected failed with error %" PRIu32 "",
2020 error);
2021
2022 break;
2023
2024 case CHANNEL_EVENT_DISCONNECTED:
2025 if ((error = drdynvc_virtual_channel_event_disconnected(drdynvc)))
2026 WLog_Print(drdynvc->log, WLOG_ERROR,
2027 "drdynvc_virtual_channel_event_disconnected failed with error %" PRIu32
2028 "",
2029 error);
2030
2031 break;
2032
2033 case CHANNEL_EVENT_TERMINATED:
2034 if ((error = drdynvc_virtual_channel_event_terminated(drdynvc)))
2035 WLog_Print(drdynvc->log, WLOG_ERROR,
2036 "drdynvc_virtual_channel_event_terminated failed with error %" PRIu32 "",
2037 error);
2038
2039 break;
2040
2041 case CHANNEL_EVENT_ATTACHED:
2042 if ((error = drdynvc_virtual_channel_event_attached(drdynvc)))
2043 WLog_Print(drdynvc->log, WLOG_ERROR,
2044 "drdynvc_virtual_channel_event_attached failed with error %" PRIu32 "",
2045 error);
2046
2047 break;
2048
2049 case CHANNEL_EVENT_DETACHED:
2050 if ((error = drdynvc_virtual_channel_event_detached(drdynvc)))
2051 WLog_Print(drdynvc->log, WLOG_ERROR,
2052 "drdynvc_virtual_channel_event_detached failed with error %" PRIu32 "",
2053 error);
2054
2055 break;
2056
2057 default:
2058 break;
2059 }
2060
2061 if (error && drdynvc->rdpcontext)
2062 setChannelError(drdynvc->rdpcontext, error,
2063 "drdynvc_virtual_channel_init_event_ex reported an error");
2064}
2065
2070static int drdynvc_get_version(DrdynvcClientContext* context)
2071{
2072 WINPR_ASSERT(context);
2073 drdynvcPlugin* drdynvc = (drdynvcPlugin*)context->handle;
2074 WINPR_ASSERT(drdynvc);
2075 return drdynvc->version;
2076}
2077
2078/* drdynvc is always built-in */
2079#define VirtualChannelEntryEx drdynvc_VirtualChannelEntryEx
2080
2081FREERDP_ENTRY_POINT(BOOL VCAPITYPE VirtualChannelEntryEx(PCHANNEL_ENTRY_POINTS_EX pEntryPoints,
2082 PVOID pInitHandle))
2083{
2084 UINT rc = 0;
2085 drdynvcPlugin* drdynvc = NULL;
2086 DrdynvcClientContext* context = NULL;
2087 CHANNEL_ENTRY_POINTS_FREERDP_EX* pEntryPointsEx = NULL;
2088 drdynvc = (drdynvcPlugin*)calloc(1, sizeof(drdynvcPlugin));
2089
2090 WINPR_ASSERT(pEntryPoints);
2091 if (!drdynvc)
2092 {
2093 WLog_ERR(TAG, "calloc failed!");
2094 return FALSE;
2095 }
2096
2097 drdynvc->channelDef.options =
2098 CHANNEL_OPTION_INITIALIZED | CHANNEL_OPTION_ENCRYPT_RDP | CHANNEL_OPTION_COMPRESS_RDP;
2099 (void)sprintf_s(drdynvc->channelDef.name, ARRAYSIZE(drdynvc->channelDef.name),
2100 DRDYNVC_SVC_CHANNEL_NAME);
2101 drdynvc->state = DRDYNVC_STATE_INITIAL;
2102 pEntryPointsEx = (CHANNEL_ENTRY_POINTS_FREERDP_EX*)pEntryPoints;
2103
2104 if ((pEntryPointsEx->cbSize >= sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX)) &&
2105 (pEntryPointsEx->MagicNumber == FREERDP_CHANNEL_MAGIC_NUMBER))
2106 {
2107 context = (DrdynvcClientContext*)calloc(1, sizeof(DrdynvcClientContext));
2108
2109 if (!context)
2110 {
2111 WLog_Print(drdynvc->log, WLOG_ERROR, "calloc failed!");
2112 free(drdynvc);
2113 return FALSE;
2114 }
2115
2116 context->handle = (void*)drdynvc;
2117 context->custom = NULL;
2118 drdynvc->context = context;
2119 context->GetVersion = drdynvc_get_version;
2120 drdynvc->rdpcontext = pEntryPointsEx->context;
2121 if (!freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2122 FreeRDP_TransportDumpReplay) &&
2123 !freerdp_settings_get_bool(drdynvc->rdpcontext->settings,
2124 FreeRDP_SynchronousDynamicChannels))
2125 drdynvc->async = TRUE;
2126 }
2127
2128 drdynvc->log = WLog_Get(TAG);
2129 WLog_Print(drdynvc->log, WLOG_DEBUG, "VirtualChannelEntryEx");
2130 CopyMemory(&(drdynvc->channelEntryPoints), pEntryPoints,
2131 sizeof(CHANNEL_ENTRY_POINTS_FREERDP_EX));
2132 drdynvc->InitHandle = pInitHandle;
2133
2134 WINPR_ASSERT(drdynvc->channelEntryPoints.pVirtualChannelInitEx);
2135 rc = drdynvc->channelEntryPoints.pVirtualChannelInitEx(
2136 drdynvc, context, pInitHandle, &drdynvc->channelDef, 1, VIRTUAL_CHANNEL_VERSION_WIN2000,
2137 drdynvc_virtual_channel_init_event_ex);
2138
2139 if (CHANNEL_RC_OK != rc)
2140 {
2141 WLog_Print(drdynvc->log, WLOG_ERROR, "pVirtualChannelInit failed with %s [%08" PRIX32 "]",
2142 WTSErrorToString(rc), rc);
2143 free(drdynvc->context);
2144 free(drdynvc);
2145 return FALSE;
2146 }
2147
2148 drdynvc->channelEntryPoints.pInterface = context;
2149 return TRUE;
2150}
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