FreeRDP
Loading...
Searching...
No Matches
libfreerdp/core/client.c
1
22#include <freerdp/config.h>
23
24#include "settings.h"
25
26#include <winpr/assert.h>
27
28#include <freerdp/log.h>
29#include <freerdp/channels/drdynvc.h>
30
31#include "rdp.h"
32#include "client.h"
33
34#define TAG FREERDP_TAG("core.client")
35
36typedef struct
37{
38 freerdp_channel_handle_fkt_t fkt;
39 void* userdata;
40} ChannelEventEntry;
41
42/* Use this instance to get access to channels in VirtualChannelInit. It is set during
43 * freerdp_connect so channels that use VirtualChannelInit must be initialized from the same thread
44 * as freerdp_connect was called */
45static WINPR_TLS freerdp* g_Instance = nullptr;
46
47/* use global counter to ensure uniqueness across channel manager instances */
48static volatile LONG g_OpenHandleSeq = 1;
49
50/* HashTable mapping channel handles to CHANNEL_OPEN_DATA */
51static INIT_ONCE g_ChannelHandlesOnce = INIT_ONCE_STATIC_INIT;
52static wHashTable* g_ChannelHandles = nullptr;
53
54static BOOL freerdp_channels_process_message_free(wMessage* message, DWORD type);
55
56static CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(rdpChannels* channels,
57 const char* name)
58{
59 WINPR_ASSERT(channels);
60 for (int index = 0; index < channels->openDataCount; index++)
61 {
62 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
63
64 if (strncmp(name, pChannelOpenData->stats.channelName, CHANNEL_NAME_LEN + 1) == 0)
65 return pChannelOpenData;
66 }
67
68 return nullptr;
69}
70
71/* returns rdpChannel for the channel name passed in */
72static rdpMcsChannel* freerdp_channels_find_channel_by_name(rdpRdp* rdp, const char* name)
73{
74 if (!rdp)
75 return nullptr;
76
77 rdpMcs* mcs = rdp->mcs;
78 WINPR_ASSERT(mcs);
79
80 for (UINT32 index = 0; index < mcs->channelCount; index++)
81 {
82 rdpMcsChannel* channel = &mcs->channels[index];
83
84 if (strncmp(name, channel->Name, CHANNEL_NAME_LEN + 1) == 0)
85 {
86 return channel;
87 }
88 }
89
90 return nullptr;
91}
92
93static rdpMcsChannel* freerdp_channels_find_channel_by_id(rdpRdp* rdp, UINT16 channel_id)
94{
95 if (!rdp)
96 return nullptr;
97
98 rdpMcs* mcs = rdp->mcs;
99 WINPR_ASSERT(mcs);
100
101 for (UINT32 index = 0; index < mcs->channelCount; index++)
102 {
103 rdpMcsChannel* channel = &mcs->channels[index];
104
105 if (channel->ChannelId == channel_id)
106 {
107 return channel;
108 }
109 }
110
111 return nullptr;
112}
113
114static void channel_queue_message_free(wMessage* msg)
115{
116 if (!msg || (msg->id != 0))
117 return;
118
119 CHANNEL_OPEN_EVENT* ev = (CHANNEL_OPEN_EVENT*)msg->wParam;
120 free(ev);
121}
122
123static void channel_queue_free(void* obj)
124{
125 wMessage* msg = (wMessage*)obj;
126 freerdp_channels_process_message_free(msg, CHANNEL_EVENT_WRITE_CANCELLED);
127 channel_queue_message_free(msg);
128}
129
130static BOOL CALLBACK init_channel_handles_table(WINPR_ATTR_UNUSED PINIT_ONCE once,
131 WINPR_ATTR_UNUSED PVOID param,
132 WINPR_ATTR_UNUSED PVOID* context)
133{
134 g_ChannelHandles = HashTable_New(TRUE);
135 return TRUE;
136}
137
138static void* channel_event_entry_clone(const void* data)
139{
140 const ChannelEventEntry* entry = data;
141 if (!entry)
142 return nullptr;
143
144 ChannelEventEntry* copy = calloc(1, sizeof(ChannelEventEntry));
145 if (!copy)
146 return nullptr;
147 *copy = *entry;
148 return copy;
149}
150
151rdpChannels* freerdp_channels_new(freerdp* instance)
152{
153 if (!InitOnceExecuteOnce(&g_ChannelHandlesOnce, init_channel_handles_table, nullptr, nullptr))
154 return nullptr;
155
156 wObject* obj = nullptr;
157 rdpChannels* channels = nullptr;
158 channels = (rdpChannels*)calloc(1, sizeof(rdpChannels));
159
160 if (!channels)
161 return nullptr;
162
163 if (!g_ChannelHandles)
164 goto error;
165 if (!InitializeCriticalSectionAndSpinCount(&channels->channelsLock, 4000))
166 goto error;
167
168 channels->instance = instance;
169 channels->queue = MessageQueue_New(nullptr);
170
171 if (!channels->queue)
172 goto error;
173
174 obj = MessageQueue_Object(channels->queue);
175 obj->fnObjectFree = channel_queue_free;
176
177 channels->channelEvents = HashTable_New(FALSE);
178 if (!channels->channelEvents)
179 goto error;
180
181 obj = HashTable_ValueObject(channels->channelEvents);
182 WINPR_ASSERT(obj);
183 obj->fnObjectFree = free;
184 obj->fnObjectNew = channel_event_entry_clone;
185 return channels;
186error:
187 WINPR_PRAGMA_DIAG_PUSH
188 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
189 freerdp_channels_free(channels);
190 WINPR_PRAGMA_DIAG_POP
191 return nullptr;
192}
193
194void freerdp_channels_free(rdpChannels* channels)
195{
196 if (!channels)
197 return;
198
199 HashTable_Free(channels->channelEvents);
200
201 DeleteCriticalSection(&channels->channelsLock);
202
203 if (channels->queue)
204 {
205 MessageQueue_Free(channels->queue);
206 channels->queue = nullptr;
207 }
208
209 free(channels);
210}
211
217static UINT freerdp_drdynvc_on_channel_connected(DrdynvcClientContext* context, const char* name,
218 void* pInterface)
219{
220 UINT status = CHANNEL_RC_OK;
221
222 WINPR_ASSERT(context);
223
224 rdpChannels* channels = (rdpChannels*)context->custom;
225 WINPR_ASSERT(channels);
226
227 freerdp* instance = channels->instance;
228 WINPR_ASSERT(instance);
229 WINPR_ASSERT(instance->context);
230
231 ChannelConnectedEventArgs e = WINPR_C_ARRAY_INIT;
232 EventArgsInit(&e, "freerdp");
233 e.name = name;
234 e.pInterface = pInterface;
235 if (PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e) < 0)
236 return ERROR_INTERNAL_ERROR;
237 return status;
238}
239
245static UINT freerdp_drdynvc_on_channel_disconnected(DrdynvcClientContext* context, const char* name,
246 void* pInterface)
247{
248 UINT status = CHANNEL_RC_OK;
249
250 WINPR_ASSERT(context);
251 rdpChannels* channels = (rdpChannels*)context->custom;
252 WINPR_ASSERT(channels);
253
254 freerdp* instance = channels->instance;
255 WINPR_ASSERT(instance);
256 WINPR_ASSERT(instance->context);
257
258 ChannelDisconnectedEventArgs e = WINPR_C_ARRAY_INIT;
259 EventArgsInit(&e, "freerdp");
260 e.name = name;
261 e.pInterface = pInterface;
262 if (PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e) < 0)
263 return ERROR_INTERNAL_ERROR;
264 return status;
265}
266
267static UINT freerdp_drdynvc_on_channel_attached(DrdynvcClientContext* context, const char* name,
268 void* pInterface)
269{
270 UINT status = CHANNEL_RC_OK;
271
272 WINPR_ASSERT(context);
273 rdpChannels* channels = (rdpChannels*)context->custom;
274 WINPR_ASSERT(channels);
275
276 freerdp* instance = channels->instance;
277 WINPR_ASSERT(instance);
278 WINPR_ASSERT(instance->context);
279
280 ChannelAttachedEventArgs e = WINPR_C_ARRAY_INIT;
281 EventArgsInit(&e, "freerdp");
282 e.name = name;
283 e.pInterface = pInterface;
284 if (PubSub_OnChannelAttached(instance->context->pubSub, instance->context, &e) < 0)
285 return ERROR_INTERNAL_ERROR;
286 return status;
287}
288
289static UINT freerdp_drdynvc_on_channel_detached(DrdynvcClientContext* context, const char* name,
290 void* pInterface)
291{
292 UINT status = CHANNEL_RC_OK;
293
294 WINPR_ASSERT(context);
295 rdpChannels* channels = (rdpChannels*)context->custom;
296 WINPR_ASSERT(channels);
297
298 freerdp* instance = channels->instance;
299 WINPR_ASSERT(instance);
300 WINPR_ASSERT(instance->context);
301
302 ChannelDetachedEventArgs e = WINPR_C_ARRAY_INIT;
303 EventArgsInit(&e, "freerdp");
304 e.name = name;
305 e.pInterface = pInterface;
306 if (PubSub_OnChannelDetached(instance->context->pubSub, instance->context, &e) < 0)
307 return ERROR_INTERNAL_ERROR;
308 return status;
309}
310
311void freerdp_channels_register_instance(WINPR_ATTR_UNUSED rdpChannels* channels, freerdp* instance)
312{
313 WINPR_ASSERT(channels);
314 WINPR_ASSERT(instance);
315 /* store instance in TLS so future VirtualChannelInit calls can use it */
316 g_Instance = instance;
317}
318
323UINT freerdp_channels_pre_connect(rdpChannels* channels, freerdp* instance)
324{
325 UINT error = CHANNEL_RC_OK;
326
327 WINPR_ASSERT(channels);
328 WINPR_ASSERT(instance);
329
330 MessageQueue_Clear(channels->queue);
331
332 for (int index = 0; index < channels->clientDataCount; index++)
333 {
334 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
335
336 if (pChannelClientData->pChannelInitEventProc)
337 {
338 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
339 CHANNEL_EVENT_INITIALIZED, nullptr, 0);
340 }
341 else if (pChannelClientData->pChannelInitEventProcEx)
342 {
343 pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
344 pChannelClientData->pInitHandle,
345 CHANNEL_EVENT_INITIALIZED, nullptr, 0);
346 }
347
348 error = getChannelError(instance->context);
349 if (CHANNEL_RC_OK != error)
350 break;
351
352 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
353 CHANNEL_INIT_DATA* pChannelInitData = &channels->initDataList[index];
354 ChannelInitializedEventArgs e = WINPR_C_ARRAY_INIT;
355 EventArgsInit(&e, "freerdp");
356 e.name = pChannelOpenData->stats.channelName;
357 e.pInterface = pChannelInitData->pInterface;
358 if (PubSub_OnChannelInitialized(instance->context->pubSub, instance->context, &e) < 0)
359 {
360 error = ERROR_INTERNAL_ERROR;
361 break;
362 }
363 }
364
365 return error;
366}
367
368UINT freerdp_channels_attach(freerdp* instance)
369{
370 UINT error = CHANNEL_RC_OK;
371
372 WINPR_ASSERT(instance);
373 WINPR_ASSERT(instance->context);
374 WINPR_ASSERT(instance->context->settings);
375
376 rdpChannels* channels = instance->context->channels;
377 const char* hostname =
378 freerdp_settings_get_string(instance->context->settings, FreeRDP_ServerHostname);
379 WINPR_ASSERT(hostname);
380 const size_t hostnameLength = strnlen(hostname, MAX_PATH);
381
382 for (int index = 0; index < channels->clientDataCount; index++)
383 {
384 union
385 {
386 const void* cpv;
387 void* pv;
388 } cnv;
389 ChannelAttachedEventArgs e = WINPR_C_ARRAY_INIT;
390
391 cnv.cpv = hostname;
392 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
393
394 if (pChannelClientData->pChannelInitEventProc)
395 {
396
397 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
398 CHANNEL_EVENT_ATTACHED, cnv.pv,
399 (UINT)hostnameLength);
400 }
401 else if (pChannelClientData->pChannelInitEventProcEx)
402 {
403 pChannelClientData->pChannelInitEventProcEx(
404 pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
405 CHANNEL_EVENT_ATTACHED, cnv.pv, (UINT)hostnameLength);
406 }
407
408 error = getChannelError(instance->context);
409 if (error != CHANNEL_RC_OK)
410 goto fail;
411
412 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
413 EventArgsInit(&e, "freerdp");
414 e.name = pChannelOpenData->stats.channelName;
415 e.pInterface = pChannelOpenData->pInterface;
416 if (PubSub_OnChannelAttached(instance->context->pubSub, instance->context, &e) < 0)
417 {
418 error = ERROR_INTERNAL_ERROR;
419 goto fail;
420 }
421 }
422
423fail:
424 return error;
425}
426
427UINT freerdp_channels_detach(freerdp* instance)
428{
429 UINT error = CHANNEL_RC_OK;
430
431 WINPR_ASSERT(instance);
432
433 rdpContext* context = instance->context;
434 WINPR_ASSERT(context);
435
436 rdpChannels* channels = context->channels;
437 WINPR_ASSERT(channels);
438
439 WINPR_ASSERT(context->settings);
440 const char* hostname = freerdp_settings_get_string(context->settings, FreeRDP_ServerHostname);
441 WINPR_ASSERT(hostname);
442 const size_t hostnameLength = strnlen(hostname, MAX_PATH);
443
444 for (int index = 0; index < channels->clientDataCount; index++)
445 {
446 union
447 {
448 const void* cpv;
449 void* pv;
450 } cnv;
451
452 ChannelDetachedEventArgs e = WINPR_C_ARRAY_INIT;
453
454 cnv.cpv = hostname;
455 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
456
457 if (pChannelClientData->pChannelInitEventProc)
458 {
459 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
460 CHANNEL_EVENT_DETACHED, cnv.pv,
461 (UINT)hostnameLength);
462 }
463 else if (pChannelClientData->pChannelInitEventProcEx)
464 {
465 pChannelClientData->pChannelInitEventProcEx(
466 pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
467 CHANNEL_EVENT_DETACHED, cnv.pv, (UINT)hostnameLength);
468 }
469
470 error = getChannelError(context);
471 if (error != CHANNEL_RC_OK)
472 goto fail;
473
474 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
475 EventArgsInit(&e, "freerdp");
476 e.name = pChannelOpenData->stats.channelName;
477 e.pInterface = pChannelOpenData->pInterface;
478 if (PubSub_OnChannelDetached(context->pubSub, context, &e) < 0)
479 {
480 error = ERROR_INTERNAL_ERROR;
481 goto fail;
482 }
483 }
484
485fail:
486 return error;
487}
488
494UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
495{
496 UINT error = CHANNEL_RC_OK;
497
498 WINPR_ASSERT(channels);
499 WINPR_ASSERT(instance);
500 WINPR_ASSERT(instance->context);
501 WINPR_ASSERT(instance->context->settings);
502
503 channels->connected = TRUE;
504 const char* hostname =
505 freerdp_settings_get_string(instance->context->settings, FreeRDP_ServerHostname);
506 WINPR_ASSERT(hostname);
507 const size_t hostnameLength = strnlen(hostname, MAX_PATH);
508
509 for (int index = 0; index < channels->clientDataCount; index++)
510 {
511 union
512 {
513 const void* pcb;
514 void* pb;
515 } cnv;
516
517 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
518 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
519
520 cnv.pcb = hostname;
521 if (pChannelClientData->pChannelInitEventProc)
522 {
523 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
524 CHANNEL_EVENT_CONNECTED, cnv.pb,
525 (UINT)hostnameLength);
526 }
527 else if (pChannelClientData->pChannelInitEventProcEx)
528 {
529 pChannelClientData->pChannelInitEventProcEx(
530 pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
531 CHANNEL_EVENT_CONNECTED, cnv.pb, (UINT)hostnameLength);
532 }
533
534 error = getChannelError(instance->context);
535 if (error != CHANNEL_RC_OK)
536 goto fail;
537
538 ChannelConnectedEventArgs e = WINPR_C_ARRAY_INIT;
539 EventArgsInit(&e, "freerdp");
540 e.name = pChannelOpenData->stats.channelName;
541 e.pInterface = pChannelOpenData->pInterface;
542 if (PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e) < 0)
543 {
544 error = ERROR_INTERNAL_ERROR;
545 goto fail;
546 }
547 }
548
549 channels->drdynvc = (DrdynvcClientContext*)freerdp_channels_get_static_channel_interface(
550 channels, DRDYNVC_SVC_CHANNEL_NAME);
551
552 if (channels->drdynvc)
553 {
554 channels->drdynvc->custom = (void*)channels;
555 channels->drdynvc->OnChannelConnected = freerdp_drdynvc_on_channel_connected;
556 channels->drdynvc->OnChannelDisconnected = freerdp_drdynvc_on_channel_disconnected;
557 channels->drdynvc->OnChannelAttached = freerdp_drdynvc_on_channel_attached;
558 channels->drdynvc->OnChannelDetached = freerdp_drdynvc_on_channel_detached;
559 }
560
561fail:
562 return error;
563}
564
565BOOL freerdp_channels_data(freerdp* instance, UINT16 channelId, const BYTE* cdata, size_t dataSize,
566 UINT32 flags, size_t totalSize)
567{
568 union
569 {
570 const BYTE* pcb;
571 BYTE* pb;
572 } data;
573
574 data.pcb = cdata;
575 if (!instance || !data.pcb)
576 {
577 WLog_ERR(TAG, "(%p, %" PRIu16 ", %p, 0x%08x): Invalid arguments",
578 WINPR_CXX_COMPAT_CAST(const void*, instance), channelId,
579 WINPR_CXX_COMPAT_CAST(const void*, data.pcb), flags);
580 return FALSE;
581 }
582
583 WINPR_ASSERT(instance->context);
584 WINPR_ASSERT(instance->context->rdp);
585
586 rdpMcs* mcs = instance->context->rdp->mcs;
587 WINPR_ASSERT(mcs);
588
589 rdpChannels* channels = instance->context->channels;
590 WINPR_ASSERT(channels);
591
592 if (!channels || !mcs)
593 {
594 return FALSE;
595 }
596
597 rdpMcsChannel* channel = nullptr;
598 for (UINT32 index = 0; index < mcs->channelCount; index++)
599 {
600 rdpMcsChannel* cur = &mcs->channels[index];
601
602 if (cur->ChannelId == channelId)
603 {
604 channel = cur;
605 break;
606 }
607 }
608
609 if (!channel)
610 {
611 return FALSE;
612 }
613
614 CHANNEL_OPEN_DATA* pChannelOpenData =
615 freerdp_channels_find_channel_open_data_by_name(channels, channel->Name);
616
617 if (!pChannelOpenData)
618 {
619 return FALSE;
620 }
621
622 pChannelOpenData->stats.bytesIn += dataSize;
623 pChannelOpenData->stats.fragmentsIn++;
624 if ((flags & CHANNEL_FLAG_LAST) != 0)
625 pChannelOpenData->stats.packetsIn++;
626
627 if (pChannelOpenData->pChannelOpenEventProc)
628 {
629 pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->stats.channelId,
630 CHANNEL_EVENT_DATA_RECEIVED, data.pb,
631 (UINT32)dataSize, (UINT32)totalSize, flags);
632 }
633 else if (pChannelOpenData->pChannelOpenEventProcEx)
634 {
635 pChannelOpenData->pChannelOpenEventProcEx(
636 pChannelOpenData->lpUserParam, pChannelOpenData->stats.channelId,
637 CHANNEL_EVENT_DATA_RECEIVED, data.pb, (UINT32)dataSize, (UINT32)totalSize, flags);
638 }
639
640 return TRUE;
641}
642
643UINT16 freerdp_channels_get_id_by_name(freerdp* instance, const char* channel_name)
644{
645 if (!instance || !channel_name)
646 return 0;
647
648 WINPR_ASSERT(instance->context);
649 WINPR_ASSERT(instance->context->rdp);
650 rdpMcsChannel* mcsChannel =
651 freerdp_channels_find_channel_by_name(instance->context->rdp, channel_name);
652 if (!mcsChannel)
653 return 0;
654
655 return mcsChannel->ChannelId;
656}
657
658const char* freerdp_channels_get_name_by_id(freerdp* instance, UINT16 channelId)
659{
660 if (!instance)
661 return nullptr;
662
663 WINPR_ASSERT(instance->context);
664 WINPR_ASSERT(instance->context->rdp);
665 rdpMcsChannel* mcsChannel =
666 freerdp_channels_find_channel_by_id(instance->context->rdp, channelId);
667 if (!mcsChannel)
668 return nullptr;
669
670 return mcsChannel->Name;
671}
672
673BOOL freerdp_channels_process_message_free(wMessage* message, DWORD type)
674{
675 WINPR_ASSERT(message);
676
677 if (message->id == WMQ_QUIT)
678 {
679 return FALSE;
680 }
681
682 if (message->id == 0)
683 {
684 CHANNEL_OPEN_EVENT* item = (CHANNEL_OPEN_EVENT*)message->wParam;
685
686 if (!item)
687 return FALSE;
688
689 CHANNEL_OPEN_DATA* pChannelOpenData = item->pChannelOpenData;
690
691 if (pChannelOpenData->pChannelOpenEventProc)
692 {
693 pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->stats.channelId, type,
694 item->UserData, item->DataLength,
695 item->DataLength, 0);
696 }
697 else if (pChannelOpenData->pChannelOpenEventProcEx)
698 {
699 pChannelOpenData->pChannelOpenEventProcEx(
700 pChannelOpenData->lpUserParam, pChannelOpenData->stats.channelId, type,
701 item->UserData, item->DataLength, item->DataLength, 0);
702 }
703 }
704
705 return TRUE;
706}
707
708static BOOL freerdp_channels_process_message(freerdp* instance, wMessage* message)
709{
710 BOOL ret = TRUE;
711 BOOL rc = FALSE;
712
713 WINPR_ASSERT(instance);
714 WINPR_ASSERT(instance->context);
715 WINPR_ASSERT(message);
716
717 if (message->id == WMQ_QUIT)
718 goto fail;
719 else if (message->id == 0)
720 {
721 CHANNEL_OPEN_EVENT* item = (CHANNEL_OPEN_EVENT*)message->wParam;
722
723 if (!item)
724 goto fail;
725
726 CHANNEL_OPEN_DATA* pChannelOpenData = item->pChannelOpenData;
727
728 if (pChannelOpenData->flags != 2)
729 {
730 freerdp_channels_process_message_free(message, CHANNEL_EVENT_WRITE_CANCELLED);
731 goto fail;
732 }
733 rdpMcsChannel* channel = freerdp_channels_find_channel_by_name(
734 instance->context->rdp, pChannelOpenData->stats.channelName);
735
736 if (channel)
737 {
738 pChannelOpenData->stats.bytesOut += item->DataLength;
739 pChannelOpenData->stats.packetsOut++;
740
741 const UINT32 VCChunkSize =
742 freerdp_settings_get_uint32(instance->context->settings, FreeRDP_VCChunkSize);
743 if (VCChunkSize == 0)
744 goto fail;
745 const uint64_t frags = (1ull * item->DataLength + VCChunkSize - 1ull) / VCChunkSize;
746 pChannelOpenData->stats.fragmentsOut += frags;
747 ret = instance->SendChannelData(instance, channel->ChannelId, item->Data,
748 item->DataLength);
749 }
750 }
751
752 if (!freerdp_channels_process_message_free(message, CHANNEL_EVENT_WRITE_COMPLETE))
753 goto fail;
754
755 rc = ret;
756
757fail:
758 IFCALL(message->Free, message);
759 return rc;
760}
761
765static BOOL freerdp_channels_process_sync(rdpChannels* channels, freerdp* instance)
766{
767 BOOL status = TRUE;
768 wMessage message = WINPR_C_ARRAY_INIT;
769
770 WINPR_ASSERT(channels);
771
772 while (MessageQueue_Peek(channels->queue, &message, TRUE))
773 {
774 if (!freerdp_channels_process_message(instance, &message))
775 status = FALSE;
776 }
777
778 return status;
779}
780
784#if defined(WITH_FREERDP_DEPRECATED)
785BOOL freerdp_channels_get_fds(rdpChannels* channels, WINPR_ATTR_UNUSED freerdp* instance,
786 void** read_fds, int* read_count, WINPR_ATTR_UNUSED void** write_fds,
787 WINPR_ATTR_UNUSED int* write_count)
788{
789 void* pfd = nullptr;
790 pfd = GetEventWaitObject(MessageQueue_Event(channels->queue));
791
792 if (pfd)
793 {
794 read_fds[*read_count] = pfd;
795 (*read_count)++;
796 }
797
798 return TRUE;
799}
800#endif
801
802void* freerdp_channels_get_static_channel_interface(rdpChannels* channels, const char* name)
803{
804 void* pInterface = nullptr;
805 CHANNEL_OPEN_DATA* pChannelOpenData =
806 freerdp_channels_find_channel_open_data_by_name(channels, name);
807
808 if (pChannelOpenData)
809 pInterface = pChannelOpenData->pInterface;
810
811 return pInterface;
812}
813
814HANDLE freerdp_channels_get_event_handle(freerdp* instance)
815{
816 if (!instance)
817 return INVALID_HANDLE_VALUE;
818
819 WINPR_ASSERT(instance->context);
820
821 rdpChannels* channels = instance->context->channels;
822 WINPR_ASSERT(channels);
823
824 return MessageQueue_Event(channels->queue);
825}
826
827static BOOL channels_process(const void* key, void* value, void* arg)
828{
829 ChannelEventEntry* entry = value;
830 rdpContext* context = arg;
831
832 WINPR_UNUSED(key);
833 WINPR_ASSERT(entry);
834
835 if (!entry->fkt)
836 return FALSE;
837 return entry->fkt(context, entry->userdata);
838}
839
840int freerdp_channels_process_pending_messages(freerdp* instance)
841{
842 if (!instance)
843 return -1;
844
845 WINPR_ASSERT(instance->context);
846
847 rdpChannels* channels = instance->context->channels;
848 WINPR_ASSERT(channels);
849
850 const DWORD status = WaitForSingleObject(MessageQueue_Event(channels->queue), 0);
851 if (status == WAIT_OBJECT_0)
852 {
853 if (!freerdp_channels_process_sync(channels, instance))
854 return -1;
855 }
856
857 if (!HashTable_Foreach(channels->channelEvents, channels_process, instance->context))
858 return -1;
859
860 return 1;
861}
862
866BOOL freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance)
867{
868 WINPR_ASSERT(channels);
869 WINPR_UNUSED(channels);
870
871 const int rc = freerdp_channels_process_pending_messages(instance);
872 return rc == 1;
873}
874
875BOOL freerdp_client_channel_register(rdpChannels* channels, HANDLE handle,
876 freerdp_channel_handle_fkt_t fkt, void* userdata)
877{
878 if (!channels || (handle == INVALID_HANDLE_VALUE) || !fkt)
879 {
880 WLog_ERR(TAG, "Invalid function arguments (channels=%p, handle=%p, fkt=%p, userdata=%p",
881 WINPR_FUNC_PTR_CAST(channels, const void*), handle,
882 WINPR_FUNC_PTR_CAST(fkt, const void*), userdata);
883 return FALSE;
884 }
885
886 ChannelEventEntry entry = { .fkt = fkt, .userdata = userdata };
887 return HashTable_Insert(channels->channelEvents, handle, &entry);
888}
889
890BOOL freerdp_client_channel_unregister(rdpChannels* channels, HANDLE handle)
891{
892 if (!channels || (handle == INVALID_HANDLE_VALUE))
893 {
894 WLog_ERR(TAG, "Invalid function arguments (channels=%p, handle=%p",
895 WINPR_CXX_COMPAT_CAST(const void*, channels), handle);
896 return FALSE;
897 }
898
899 return HashTable_Remove(channels->channelEvents, handle);
900}
901
902SSIZE_T freerdp_client_channel_get_registered_event_handles(rdpChannels* channels, HANDLE* events,
903 DWORD count)
904{
905 SSIZE_T rc = -1;
906
907 WINPR_ASSERT(channels);
908 WINPR_ASSERT(events || (count == 0));
909
910 HashTable_Lock(channels->channelEvents);
911 size_t len = HashTable_Count(channels->channelEvents);
912 if (len <= count)
913 {
914 ULONG_PTR* keys = nullptr;
915 const size_t nrKeys = HashTable_GetKeys(channels->channelEvents, &keys);
916 if ((nrKeys <= SSIZE_MAX) && (nrKeys == len))
917 {
918 for (size_t x = 0; x < nrKeys; x++)
919 {
920 HANDLE cur = (HANDLE)keys[x];
921 events[x] = cur;
922 }
923 rc = (SSIZE_T)nrKeys;
924 }
925 free(keys);
926 }
927 HashTable_Unlock(channels->channelEvents);
928 return rc;
929}
930
931UINT freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance)
932{
933 UINT error = CHANNEL_RC_OK;
934
935 WINPR_ASSERT(channels);
936
937 if (!channels->connected)
938 return 0;
939
940 freerdp_channels_check_fds(channels, instance);
941
942 /* tell all libraries we are shutting down */
943 for (int index = 0; index < channels->clientDataCount; index++)
944 {
945 ChannelDisconnectedEventArgs e = WINPR_C_ARRAY_INIT;
946 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
947
948 if (pChannelClientData->pChannelInitEventProc)
949 {
950 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
951 CHANNEL_EVENT_DISCONNECTED, nullptr, 0);
952 }
953 else if (pChannelClientData->pChannelInitEventProcEx)
954 {
955 pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
956 pChannelClientData->pInitHandle,
957 CHANNEL_EVENT_DISCONNECTED, nullptr, 0);
958 }
959
960 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
961 EventArgsInit(&e, "freerdp");
962 e.name = pChannelOpenData->stats.channelName;
963 e.pInterface = pChannelOpenData->pInterface;
964 if (PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e) < 0)
965 error = ERROR_INTERNAL_ERROR;
966 }
967
968 channels->connected = FALSE;
969
970 /* Flush pending messages */
971 freerdp_channels_check_fds(channels, instance);
972 return error;
973}
974
975void freerdp_channels_close(rdpChannels* channels, freerdp* instance)
976{
977 WINPR_ASSERT(channels);
978 WINPR_ASSERT(instance);
979
980 MessageQueue_PostQuit(channels->queue, 0);
981 freerdp_channels_check_fds(channels, instance);
982
983 /* tell all libraries we are shutting down */
984 for (int index = 0; index < channels->clientDataCount; index++)
985 {
986 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[index];
987
988 if (pChannelClientData->pChannelInitEventProc)
989 {
990 pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
991 CHANNEL_EVENT_TERMINATED, nullptr, 0);
992 }
993 else if (pChannelClientData->pChannelInitEventProcEx)
994 {
995 pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
996 pChannelClientData->pInitHandle,
997 CHANNEL_EVENT_TERMINATED, nullptr, 0);
998 }
999
1000 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
1001 CHANNEL_INIT_DATA* pChannelInitData = &channels->initDataList[index];
1002 ChannelTerminatedEventArgs e = WINPR_C_ARRAY_INIT;
1003 EventArgsInit(&e, "freerdp");
1004 e.name = pChannelOpenData->stats.channelName;
1005 e.pInterface = pChannelInitData->pInterface;
1006 if (PubSub_OnChannelTerminated(instance->context->pubSub, instance->context, &e) < 0)
1007 {
1008 WLog_WARN(TAG, "PubSub_OnChannelTerminated(%s) failed",
1009 pChannelOpenData->stats.channelName);
1010 }
1011 }
1012
1013 for (int index = 0; index < channels->openDataCount; index++)
1014 {
1015 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[index];
1016 HashTable_Remove(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->stats.channelId);
1017 }
1018
1019 channels->openDataCount = 0;
1020 channels->initDataCount = 0;
1021 channels->clientDataCount = 0;
1022
1023 WINPR_ASSERT(instance->context);
1024 WINPR_ASSERT(instance->context->settings);
1025 instance->context->settings->ChannelCount = 0;
1026 g_Instance = nullptr;
1027}
1028
1029static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
1030 LPVOID lpUserParam, LPVOID clientContext, LPVOID pInitHandle, PCHANNEL_DEF pChannel,
1031 INT channelCount, ULONG versionRequested, PCHANNEL_INIT_EVENT_EX_FN pChannelInitEventProcEx)
1032{
1033 if (!pInitHandle)
1034 return CHANNEL_RC_BAD_INIT_HANDLE;
1035
1036 if (!pChannel)
1037 return CHANNEL_RC_BAD_CHANNEL;
1038
1039 if ((channelCount <= 0) || !pChannelInitEventProcEx)
1040 return CHANNEL_RC_INITIALIZATION_ERROR;
1041
1042 CHANNEL_INIT_DATA* pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
1043 WINPR_ASSERT(pChannelInitData);
1044
1045 rdpChannels* channels = pChannelInitData->channels;
1046 WINPR_ASSERT(channels);
1047
1048 if (!channels->can_call_init)
1049 return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
1050
1051 if ((channels->openDataCount + channelCount) > CHANNEL_MAX_COUNT)
1052 return CHANNEL_RC_TOO_MANY_CHANNELS;
1053
1054 if (channels->connected)
1055 return CHANNEL_RC_ALREADY_CONNECTED;
1056
1057 if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
1058 {
1059 }
1060
1061 for (int index = 0; index < channelCount; index++)
1062 {
1063 const PCHANNEL_DEF pChannelDef = &pChannel[index];
1064
1065 if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != nullptr)
1066 {
1067 return CHANNEL_RC_BAD_CHANNEL;
1068 }
1069 }
1070
1071 pChannelInitData->pInterface = clientContext;
1072
1073 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[channels->clientDataCount];
1074 pChannelClientData->pChannelInitEventProcEx = pChannelInitEventProcEx;
1075 pChannelClientData->pInitHandle = pInitHandle;
1076 pChannelClientData->lpUserParam = lpUserParam;
1077 channels->clientDataCount++;
1078
1079 WINPR_ASSERT(channels->instance);
1080 WINPR_ASSERT(channels->instance->context);
1081
1082 rdpSettings* settings = channels->instance->context->settings;
1083 WINPR_ASSERT(settings);
1084
1085 for (int index = 0; index < channelCount; index++)
1086 {
1087 const PCHANNEL_DEF pChannelDef = &pChannel[index];
1088 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[channels->openDataCount];
1089
1090 WINPR_ASSERT(pChannelOpenData);
1091
1092 const LONG hdl = InterlockedIncrement(&g_OpenHandleSeq);
1093 pChannelOpenData->stats.channelId = WINPR_ASSERTING_INT_CAST(uint32_t, hdl);
1094 pChannelOpenData->channels = channels;
1095 pChannelOpenData->lpUserParam = lpUserParam;
1096 if (!HashTable_Insert(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->stats.channelId,
1097 (void*)pChannelOpenData))
1098 {
1099 pChannelInitData->pInterface = nullptr;
1100 return CHANNEL_RC_INITIALIZATION_ERROR;
1101 }
1102 pChannelOpenData->flags = 1; /* init */
1103 strncpy(pChannelOpenData->stats.channelName, pChannelDef->name, CHANNEL_NAME_LEN);
1104 pChannelOpenData->options = pChannelDef->options;
1105
1106 const UINT32 max = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
1107 WINPR_ASSERT(max >= CHANNEL_MAX_COUNT);
1108 if (settings->ChannelCount < max)
1109 {
1110 CHANNEL_DEF* channel = freerdp_settings_get_pointer_array_writable(
1111 settings, FreeRDP_ChannelDefArray, settings->ChannelCount);
1112 if (!channel)
1113 continue;
1114 strncpy(channel->name, pChannelDef->name, CHANNEL_NAME_LEN);
1115 channel->options = pChannelDef->options;
1116 settings->ChannelCount++;
1117 }
1118
1119 channels->openDataCount++;
1120 }
1121
1122 return CHANNEL_RC_OK;
1123}
1124
1125static UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle, PCHANNEL_DEF pChannel,
1126 INT channelCount, ULONG versionRequested,
1127 PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
1128{
1129 /* g_Instance should have been set during freerdp_connect - otherwise VirtualChannelInit was
1130 * called from a different thread */
1131 if (!g_Instance || !g_Instance->context)
1132 return CHANNEL_RC_NOT_INITIALIZED;
1133
1134 rdpChannels* channels = g_Instance->context->channels;
1135
1136 if (!ppInitHandle || !channels)
1137 return CHANNEL_RC_BAD_INIT_HANDLE;
1138
1139 if (!pChannel)
1140 return CHANNEL_RC_BAD_CHANNEL;
1141
1142 if ((channelCount <= 0) || !pChannelInitEventProc)
1143 return CHANNEL_RC_INITIALIZATION_ERROR;
1144
1145 CHANNEL_INIT_DATA* pChannelInitData = &(channels->initDataList[channels->initDataCount]);
1146 *ppInitHandle = pChannelInitData;
1147 channels->initDataCount++;
1148 pChannelInitData->channels = channels;
1149 pChannelInitData->pInterface = nullptr;
1150
1151 if (!channels->can_call_init)
1152 return CHANNEL_RC_NOT_IN_VIRTUALCHANNELENTRY;
1153
1154 if (channels->openDataCount + channelCount > CHANNEL_MAX_COUNT)
1155 return CHANNEL_RC_TOO_MANY_CHANNELS;
1156
1157 if (channels->connected)
1158 return CHANNEL_RC_ALREADY_CONNECTED;
1159
1160 if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
1161 {
1162 }
1163
1164 PCHANNEL_DEF pChannelDef = nullptr;
1165 for (int index = 0; index < channelCount; index++)
1166 {
1167 pChannelDef = &pChannel[index];
1168
1169 if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != nullptr)
1170 {
1171 return CHANNEL_RC_BAD_CHANNEL;
1172 }
1173 }
1174
1175 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[channels->clientDataCount];
1176 pChannelClientData->pChannelInitEventProc = pChannelInitEventProc;
1177 pChannelClientData->pInitHandle = *ppInitHandle;
1178 channels->clientDataCount++;
1179
1180 rdpSettings* settings = channels->instance->context->settings;
1181
1182 for (int index = 0; index < channelCount; index++)
1183 {
1184 UINT32 ChannelCount = freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount);
1185
1186 CHANNEL_OPEN_DATA* pChannelOpenData = &channels->openDataList[channels->openDataCount];
1187
1188 const LONG hdl = InterlockedIncrement(&g_OpenHandleSeq);
1189 pChannelOpenData->stats.channelId = WINPR_ASSERTING_INT_CAST(uint32_t, hdl);
1190 pChannelOpenData->channels = channels;
1191 if (!HashTable_Insert(g_ChannelHandles, (void*)(UINT_PTR)pChannelOpenData->stats.channelId,
1192 (void*)pChannelOpenData))
1193 return CHANNEL_RC_INITIALIZATION_ERROR;
1194 pChannelOpenData->flags = 1; /* init */
1195 strncpy(pChannelOpenData->stats.channelName, pChannelDef->name, CHANNEL_NAME_LEN);
1196 pChannelOpenData->options = pChannelDef->options;
1197
1198 if (ChannelCount < CHANNEL_MAX_COUNT)
1199 {
1200 CHANNEL_DEF* channel = freerdp_settings_get_pointer_array_writable(
1201 settings, FreeRDP_ChannelDefArray, ChannelCount++);
1202 strncpy(channel->name, pChannelDef->name, CHANNEL_NAME_LEN);
1203 channel->options = pChannelDef->options;
1204 if (!freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, ChannelCount))
1205 return ERROR_INTERNAL_ERROR;
1206 }
1207
1208 channels->openDataCount++;
1209 }
1210
1211 return CHANNEL_RC_OK;
1212}
1213
1214static UINT VCAPITYPE
1215FreeRDP_VirtualChannelOpenEx(LPVOID pInitHandle, LPDWORD pOpenHandle, PCHAR pChannelName,
1216 PCHANNEL_OPEN_EVENT_EX_FN pChannelOpenEventProcEx)
1217{
1218 CHANNEL_INIT_DATA* pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
1219 WINPR_ASSERT(pChannelInitData);
1220
1221 rdpChannels* channels = pChannelInitData->channels;
1222 WINPR_ASSERT(channels);
1223
1224 void* pInterface = pChannelInitData->pInterface;
1225
1226 if (!pOpenHandle)
1227 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1228
1229 if (!pChannelOpenEventProcEx)
1230 return CHANNEL_RC_BAD_PROC;
1231
1232 if (!channels->connected)
1233 return CHANNEL_RC_NOT_CONNECTED;
1234
1235 CHANNEL_OPEN_DATA* pChannelOpenData =
1236 freerdp_channels_find_channel_open_data_by_name(channels, pChannelName);
1237
1238 if (!pChannelOpenData)
1239 return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
1240
1241 if (pChannelOpenData->flags == 2)
1242 return CHANNEL_RC_ALREADY_OPEN;
1243
1244 pChannelOpenData->flags = 2; /* open */
1245 pChannelOpenData->pInterface = pInterface;
1246 pChannelOpenData->pChannelOpenEventProcEx = pChannelOpenEventProcEx;
1247 *pOpenHandle = pChannelOpenData->stats.channelId;
1248 return CHANNEL_RC_OK;
1249}
1250
1251static UINT VCAPITYPE FreeRDP_VirtualChannelOpen(LPVOID pInitHandle, LPDWORD pOpenHandle,
1252 PCHAR pChannelName,
1253 PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
1254{
1255 CHANNEL_INIT_DATA* pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
1256 WINPR_ASSERT(pChannelInitData);
1257
1258 rdpChannels* channels = pChannelInitData->channels;
1259 void* pInterface = pChannelInitData->pInterface;
1260
1261 if (!pOpenHandle)
1262 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1263
1264 if (!pChannelOpenEventProc)
1265 return CHANNEL_RC_BAD_PROC;
1266
1267 if (!channels->connected)
1268 return CHANNEL_RC_NOT_CONNECTED;
1269
1270 CHANNEL_OPEN_DATA* pChannelOpenData =
1271 freerdp_channels_find_channel_open_data_by_name(channels, pChannelName);
1272
1273 if (!pChannelOpenData)
1274 return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
1275
1276 if (pChannelOpenData->flags == 2)
1277 return CHANNEL_RC_ALREADY_OPEN;
1278
1279 pChannelOpenData->flags = 2; /* open */
1280 pChannelOpenData->pInterface = pInterface;
1281 pChannelOpenData->pChannelOpenEventProc = pChannelOpenEventProc;
1282 *pOpenHandle = pChannelOpenData->stats.channelId;
1283 return CHANNEL_RC_OK;
1284}
1285
1286static UINT VCAPITYPE FreeRDP_VirtualChannelCloseEx(LPVOID pInitHandle, DWORD openHandle)
1287{
1288 if (!pInitHandle)
1289 return CHANNEL_RC_BAD_INIT_HANDLE;
1290
1291 CHANNEL_OPEN_DATA* pChannelOpenData =
1292 HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
1293
1294 if (!pChannelOpenData)
1295 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1296
1297 if (pChannelOpenData->flags != 2)
1298 return CHANNEL_RC_NOT_OPEN;
1299
1300 pChannelOpenData->flags = 0;
1301 return CHANNEL_RC_OK;
1302}
1303
1304static UINT VCAPITYPE FreeRDP_VirtualChannelClose(DWORD openHandle)
1305{
1306 CHANNEL_OPEN_DATA* pChannelOpenData =
1307 HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
1308
1309 if (!pChannelOpenData)
1310 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1311
1312 if (pChannelOpenData->flags != 2)
1313 return CHANNEL_RC_NOT_OPEN;
1314
1315 pChannelOpenData->flags = 0;
1316 return CHANNEL_RC_OK;
1317}
1318
1319static UINT VCAPITYPE FreeRDP_VirtualChannelWriteEx(LPVOID pInitHandle, DWORD openHandle,
1320 LPVOID pData, ULONG dataLength,
1321 LPVOID pUserData)
1322{
1323 if (!pInitHandle)
1324 return CHANNEL_RC_BAD_INIT_HANDLE;
1325
1326 CHANNEL_INIT_DATA* pChannelInitData = (CHANNEL_INIT_DATA*)pInitHandle;
1327 rdpChannels* channels = pChannelInitData->channels;
1328
1329 if (!channels)
1330 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1331
1332 CHANNEL_OPEN_DATA* pChannelOpenData =
1333 HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
1334
1335 if (!pChannelOpenData)
1336 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1337
1338 if (!channels->connected)
1339 return CHANNEL_RC_NOT_CONNECTED;
1340
1341 if (!pData)
1342 return CHANNEL_RC_NULL_DATA;
1343
1344 if (!dataLength)
1345 return CHANNEL_RC_ZERO_LENGTH;
1346
1347 if (pChannelOpenData->flags != 2)
1348 return CHANNEL_RC_NOT_OPEN;
1349
1350 CHANNEL_OPEN_EVENT* pChannelOpenEvent = (CHANNEL_OPEN_EVENT*)malloc(sizeof(CHANNEL_OPEN_EVENT));
1351
1352 if (!pChannelOpenEvent)
1353 return CHANNEL_RC_NO_MEMORY;
1354
1355 pChannelOpenEvent->Data = pData;
1356 pChannelOpenEvent->DataLength = dataLength;
1357 pChannelOpenEvent->UserData = pUserData;
1358 pChannelOpenEvent->pChannelOpenData = pChannelOpenData;
1359
1360 const wMessage message = { .context = channels,
1361 .id = 0,
1362 .wParam = pChannelOpenEvent,
1363 .lParam = nullptr,
1364 .Free = channel_queue_message_free };
1365
1366 if (!MessageQueue_Dispatch(channels->queue, &message))
1367 {
1368 free(pChannelOpenEvent);
1369 return CHANNEL_RC_NO_MEMORY;
1370 }
1371
1372 return CHANNEL_RC_OK;
1373}
1374
1375static UINT VCAPITYPE FreeRDP_VirtualChannelWrite(DWORD openHandle, LPVOID pData, ULONG dataLength,
1376 LPVOID pUserData)
1377{
1378 CHANNEL_OPEN_DATA* pChannelOpenData =
1379 HashTable_GetItemValue(g_ChannelHandles, (void*)(UINT_PTR)openHandle);
1380
1381 if (!pChannelOpenData)
1382 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1383
1384 rdpChannels* channels = pChannelOpenData->channels;
1385 if (!channels)
1386 return CHANNEL_RC_BAD_CHANNEL_HANDLE;
1387
1388 if (!channels->connected)
1389 return CHANNEL_RC_NOT_CONNECTED;
1390
1391 if (!pData)
1392 return CHANNEL_RC_NULL_DATA;
1393
1394 if (!dataLength)
1395 return CHANNEL_RC_ZERO_LENGTH;
1396
1397 if (pChannelOpenData->flags != 2)
1398 return CHANNEL_RC_NOT_OPEN;
1399
1400 CHANNEL_OPEN_EVENT* pChannelOpenEvent = (CHANNEL_OPEN_EVENT*)malloc(sizeof(CHANNEL_OPEN_EVENT));
1401
1402 if (!pChannelOpenEvent)
1403 return CHANNEL_RC_NO_MEMORY;
1404
1405 pChannelOpenEvent->Data = pData;
1406 pChannelOpenEvent->DataLength = dataLength;
1407 pChannelOpenEvent->UserData = pUserData;
1408 pChannelOpenEvent->pChannelOpenData = pChannelOpenData;
1409
1410 const wMessage message = { .context = channels,
1411 .id = 0,
1412 .wParam = pChannelOpenEvent,
1413 .lParam = nullptr,
1414 .Free = channel_queue_message_free };
1415
1416 if (!MessageQueue_Dispatch(channels->queue, &message))
1417 {
1418 free(pChannelOpenEvent);
1419 return CHANNEL_RC_NO_MEMORY;
1420 }
1421
1422 return CHANNEL_RC_OK;
1423}
1424
1425static BOOL freerdp_channels_is_loaded(rdpChannels* channels, PVIRTUALCHANNELENTRY entry)
1426{
1427 WINPR_ASSERT(channels);
1428 for (int i = 0; i < channels->clientDataCount; i++)
1429 {
1430 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[i];
1431
1432 if (pChannelClientData->entry == entry)
1433 return TRUE;
1434 }
1435
1436 return FALSE;
1437}
1438
1439static BOOL freerdp_channels_is_loaded_ex(rdpChannels* channels, PVIRTUALCHANNELENTRYEX entryEx)
1440{
1441 WINPR_ASSERT(channels);
1442 for (int i = 0; i < channels->clientDataCount; i++)
1443 {
1444 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[i];
1445
1446 if (pChannelClientData->entryEx == entryEx)
1447 return TRUE;
1448 }
1449
1450 return FALSE;
1451}
1452
1453void freerdp_channel_client_stats_free(StaticClientChannelStats* stats)
1454{
1455 if (stats)
1456 free(stats->stats);
1457 free(stats);
1458}
1459
1460StaticClientChannelStats* freerdp_channels_client_stats(rdpChannels* channels)
1461{
1462 WINPR_ASSERT(channels);
1463
1464 if (channels->openDataCount <= 0)
1465 return nullptr;
1466
1467 const size_t odc = WINPR_ASSERTING_INT_CAST(size_t, channels->openDataCount);
1468 StaticClientChannelStat* stats = calloc(odc, sizeof(StaticClientChannelStat));
1469 if (!stats)
1470 return nullptr;
1471
1472 for (int i = 0; i < channels->openDataCount; i++)
1473 {
1474 const CHANNEL_OPEN_DATA* pChannelClientData = &channels->openDataList[i];
1475 StaticClientChannelStat* stat = &stats[i];
1476
1477 *stat = pChannelClientData->stats;
1478 }
1479
1480 StaticClientChannelStats* statsw = calloc(1, sizeof(StaticClientChannelStats));
1481 if (!statsw)
1482 {
1483 free(stats);
1484 return nullptr;
1485 }
1486 statsw->count = odc;
1487 statsw->stats = stats;
1488 return statsw;
1489}
1490
1491int freerdp_channels_client_load(rdpChannels* channels, WINPR_ATTR_UNUSED rdpSettings* settings,
1492 PVIRTUALCHANNELENTRY entry, void* data)
1493{
1494 WINPR_ASSERT(channels);
1495 WINPR_ASSERT(channels->instance);
1496 WINPR_ASSERT(channels->instance->context);
1497 WINPR_ASSERT(entry);
1498
1499 if (channels->clientDataCount + 1 > CHANNEL_MAX_COUNT)
1500 {
1501 WLog_ERR(TAG, "error: too many channels");
1502 return 1;
1503 }
1504
1505 if (freerdp_channels_is_loaded(channels, entry))
1506 {
1507 WLog_WARN(TAG, "Skipping, channel already loaded");
1508 return 0;
1509 }
1510
1511 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[channels->clientDataCount];
1512 pChannelClientData->entry = entry;
1513
1514 CHANNEL_ENTRY_POINTS_FREERDP EntryPoints = { .cbSize = sizeof(EntryPoints),
1515 .protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000,
1516 .pVirtualChannelInit = FreeRDP_VirtualChannelInit,
1517 .pVirtualChannelOpen = FreeRDP_VirtualChannelOpen,
1518 .pVirtualChannelClose =
1519 FreeRDP_VirtualChannelClose,
1520 .pVirtualChannelWrite =
1521 FreeRDP_VirtualChannelWrite,
1522 .MagicNumber = FREERDP_CHANNEL_MAGIC_NUMBER,
1523 .pExtendedData = data,
1524 .context = channels->instance->context };
1525 /* enable VirtualChannelInit */
1526 union
1527 {
1528 PCHANNEL_ENTRY_POINTS_FREERDP pfx;
1529 PCHANNEL_ENTRY_POINTS px;
1530 } ptr;
1531
1532 ptr.pfx = &EntryPoints;
1533
1534 channels->can_call_init = TRUE;
1535 EnterCriticalSection(&channels->channelsLock);
1536 const BOOL status = pChannelClientData->entry(ptr.px);
1537 LeaveCriticalSection(&channels->channelsLock);
1538 /* disable MyVirtualChannelInit */
1539 channels->can_call_init = FALSE;
1540
1541 if (!status)
1542 {
1543 WLog_ERR(TAG, "error: channel export function call failed");
1544 return 1;
1545 }
1546
1547 return 0;
1548}
1549
1550int freerdp_channels_client_load_ex(rdpChannels* channels, WINPR_ATTR_UNUSED rdpSettings* settings,
1551 PVIRTUALCHANNELENTRYEX entryEx, void* data)
1552{
1553 WINPR_ASSERT(channels);
1554 WINPR_ASSERT(channels->instance);
1555 WINPR_ASSERT(channels->instance->context);
1556 WINPR_ASSERT(entryEx);
1557
1558 if (channels->clientDataCount + 1 > CHANNEL_MAX_COUNT)
1559 {
1560 WLog_ERR(TAG, "error: too many channels");
1561 return 1;
1562 }
1563
1564 if (freerdp_channels_is_loaded_ex(channels, entryEx))
1565 {
1566 WLog_WARN(TAG, "Skipping, channel already loaded");
1567 return 0;
1568 }
1569
1570 CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[channels->clientDataCount];
1571 pChannelClientData->entryEx = entryEx;
1572
1573 CHANNEL_INIT_DATA* pChannelInitData = &(channels->initDataList[channels->initDataCount++]);
1574 void* pInitHandle = pChannelInitData;
1575 pChannelInitData->channels = channels;
1576
1577 CHANNEL_ENTRY_POINTS_FREERDP_EX EntryPointsEx = {
1578 .cbSize = sizeof(EntryPointsEx),
1579 .protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000,
1580 .pVirtualChannelInitEx = FreeRDP_VirtualChannelInitEx,
1581 .pVirtualChannelOpenEx = FreeRDP_VirtualChannelOpenEx,
1582 .pVirtualChannelCloseEx = FreeRDP_VirtualChannelCloseEx,
1583 .pVirtualChannelWriteEx = FreeRDP_VirtualChannelWriteEx,
1584 .MagicNumber = FREERDP_CHANNEL_MAGIC_NUMBER,
1585 .pExtendedData = data,
1586 .context = channels->instance->context
1587 };
1588
1589 union
1590 {
1591 PCHANNEL_ENTRY_POINTS_FREERDP_EX pfx;
1592 PCHANNEL_ENTRY_POINTS_EX px;
1593 } ptr;
1594
1595 ptr.pfx = &EntryPointsEx;
1596
1597 /* enable VirtualChannelInit */
1598 channels->can_call_init = TRUE;
1599 EnterCriticalSection(&channels->channelsLock);
1600 const BOOL status = pChannelClientData->entryEx(ptr.px, pInitHandle);
1601 LeaveCriticalSection(&channels->channelsLock);
1602 /* disable MyVirtualChannelInit */
1603 channels->can_call_init = FALSE;
1604
1605 if (!status)
1606 {
1607 WLog_ERR(TAG, "error: channel export function call failed");
1608 return 1;
1609 }
1610
1611 return 0;
1612}
1613
1618int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings, const char* name,
1619 void* data)
1620{
1621 PVIRTUALCHANNELENTRY entry =
1622 freerdp_load_channel_addin_entry(name, nullptr, nullptr, FREERDP_ADDIN_CHANNEL_STATIC);
1623
1624 if (!entry)
1625 return 1;
1626
1627 return freerdp_channels_client_load(channels, settings, entry, data);
1628}
freerdp_settings_get_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_uint32
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
CHANNEL_CLIENT_DATA
Definition libfreerdp/core/client.h:44
CHANNEL_DEF
Definition wtsapi.h:78
CHANNEL_ENTRY_POINTS_FREERDP_EX
Definition svc.h:60
CHANNEL_ENTRY_POINTS_FREERDP
Definition svc.h:43
CHANNEL_INIT_DATA
Definition libfreerdp/core/client.h:80
CHANNEL_OPEN_DATA
Definition libfreerdp/core/client.h:54
CHANNEL_OPEN_EVENT
Definition libfreerdp/core/client.h:66
RTL_RUN_ONCE
Definition include/winpr/synch.h:388
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectNew
WINPR_ATTR_NODISCARD OBJECT_NEW_FN fnObjectNew
Definition collections.h:54