FreeRDP
Loading...
Searching...
No Matches
mcs.c
1
24#include <freerdp/config.h>
25
26#include <winpr/crt.h>
27#include <winpr/assert.h>
28#include <freerdp/log.h>
29
30#include "gcc.h"
31
32#include "mcs.h"
33#include "tpdu.h"
34#include "tpkt.h"
35#include "client.h"
36#include "connection.h"
37
38#define MCS_TAG FREERDP_TAG("core")
39
169static const BYTE callingDomainSelector[1] = { 0x01 };
170static const BYTE calledDomainSelector[1] = { 0x01 };
171
172/*
173static const char* const mcs_result_enumerated[] =
174{
175 "rt-successful",
176 "rt-domain-merging",
177 "rt-domain-not-hierarchical",
178 "rt-no-such-channel",
179 "rt-no-such-domain",
180 "rt-no-such-user",
181 "rt-not-admitted",
182 "rt-other-user-id",
183 "rt-parameters-unacceptable",
184 "rt-token-not-available",
185 "rt-token-not-possessed",
186 "rt-too-many-channels",
187 "rt-too-many-tokens",
188 "rt-too-many-users",
189 "rt-unspecified-failure",
190 "rt-user-rejected"
191};
192*/
193
194const char* mcs_domain_pdu_string(DomainMCSPDU pdu)
195{
196 switch (pdu)
197 {
198 case DomainMCSPDU_PlumbDomainIndication:
199 return "DomainMCSPDU_PlumbDomainIndication";
200 case DomainMCSPDU_ErectDomainRequest:
201 return "DomainMCSPDU_ErectDomainRequest";
202 case DomainMCSPDU_MergeChannelsRequest:
203 return "DomainMCSPDU_MergeChannelsRequest";
204 case DomainMCSPDU_MergeChannelsConfirm:
205 return "DomainMCSPDU_MergeChannelsConfirm";
206 case DomainMCSPDU_PurgeChannelsIndication:
207 return "DomainMCSPDU_PurgeChannelsIndication";
208 case DomainMCSPDU_MergeTokensRequest:
209 return "DomainMCSPDU_MergeTokensRequest";
210 case DomainMCSPDU_MergeTokensConfirm:
211 return "DomainMCSPDU_MergeTokensConfirm";
212 case DomainMCSPDU_PurgeTokensIndication:
213 return "DomainMCSPDU_PurgeTokensIndication";
214 case DomainMCSPDU_DisconnectProviderUltimatum:
215 return "DomainMCSPDU_DisconnectProviderUltimatum";
216 case DomainMCSPDU_RejectMCSPDUUltimatum:
217 return "DomainMCSPDU_RejectMCSPDUUltimatum";
218 case DomainMCSPDU_AttachUserRequest:
219 return "DomainMCSPDU_AttachUserRequest";
220 case DomainMCSPDU_AttachUserConfirm:
221 return "DomainMCSPDU_AttachUserConfirm";
222 case DomainMCSPDU_DetachUserRequest:
223 return "DomainMCSPDU_DetachUserRequest";
224 case DomainMCSPDU_DetachUserIndication:
225 return "DomainMCSPDU_DetachUserIndication";
226 case DomainMCSPDU_ChannelJoinRequest:
227 return "DomainMCSPDU_ChannelJoinRequest";
228 case DomainMCSPDU_ChannelJoinConfirm:
229 return "DomainMCSPDU_ChannelJoinConfirm";
230 case DomainMCSPDU_ChannelLeaveRequest:
231 return "DomainMCSPDU_ChannelLeaveRequest";
232 case DomainMCSPDU_ChannelConveneRequest:
233 return "DomainMCSPDU_ChannelConveneRequest";
234 case DomainMCSPDU_ChannelConveneConfirm:
235 return "DomainMCSPDU_ChannelConveneConfirm";
236 case DomainMCSPDU_ChannelDisbandRequest:
237 return "DomainMCSPDU_ChannelDisbandRequest";
238 case DomainMCSPDU_ChannelDisbandIndication:
239 return "DomainMCSPDU_ChannelDisbandIndication";
240 case DomainMCSPDU_ChannelAdmitRequest:
241 return "DomainMCSPDU_ChannelAdmitRequest";
242 case DomainMCSPDU_ChannelAdmitIndication:
243 return "DomainMCSPDU_ChannelAdmitIndication";
244 case DomainMCSPDU_ChannelExpelRequest:
245 return "DomainMCSPDU_ChannelExpelRequest";
246 case DomainMCSPDU_ChannelExpelIndication:
247 return "DomainMCSPDU_ChannelExpelIndication";
248 case DomainMCSPDU_SendDataRequest:
249 return "DomainMCSPDU_SendDataRequest";
250 case DomainMCSPDU_SendDataIndication:
251 return "DomainMCSPDU_SendDataIndication";
252 case DomainMCSPDU_UniformSendDataRequest:
253 return "DomainMCSPDU_UniformSendDataRequest";
254 case DomainMCSPDU_UniformSendDataIndication:
255 return "DomainMCSPDU_UniformSendDataIndication";
256 case DomainMCSPDU_TokenGrabRequest:
257 return "DomainMCSPDU_TokenGrabRequest";
258 case DomainMCSPDU_TokenGrabConfirm:
259 return "DomainMCSPDU_TokenGrabConfirm";
260 case DomainMCSPDU_TokenInhibitRequest:
261 return "DomainMCSPDU_TokenInhibitRequest";
262 case DomainMCSPDU_TokenInhibitConfirm:
263 return "DomainMCSPDU_TokenInhibitConfirm";
264 case DomainMCSPDU_TokenGiveRequest:
265 return "DomainMCSPDU_TokenGiveRequest";
266 case DomainMCSPDU_TokenGiveIndication:
267 return "DomainMCSPDU_TokenGiveIndication";
268 case DomainMCSPDU_TokenGiveResponse:
269 return "DomainMCSPDU_TokenGiveResponse";
270 case DomainMCSPDU_TokenGiveConfirm:
271 return "DomainMCSPDU_TokenGiveConfirm";
272 case DomainMCSPDU_TokenPleaseRequest:
273 return "DomainMCSPDU_TokenPleaseRequest";
274 case DomainMCSPDU_TokenPleaseConfirm:
275 return "DomainMCSPDU_TokenPleaseConfirm";
276 case DomainMCSPDU_TokenReleaseRequest:
277 return "DomainMCSPDU_TokenReleaseRequest";
278 case DomainMCSPDU_TokenReleaseConfirm:
279 return "DomainMCSPDU_TokenReleaseConfirm";
280 case DomainMCSPDU_TokenTestRequest:
281 return "DomainMCSPDU_TokenTestRequest";
282 case DomainMCSPDU_TokenTestConfirm:
283 return "DomainMCSPDU_TokenTestConfirm";
284 case DomainMCSPDU_enum_length:
285 return "DomainMCSPDU_enum_length";
286 default:
287 return "DomainMCSPDU_UNKNOWN";
288 }
289}
290
291static BOOL mcs_merge_domain_parameters(wLog* log, DomainParameters* targetParameters,
292 DomainParameters* minimumParameters,
293 DomainParameters* maximumParameters,
294 DomainParameters* pOutParameters);
295
296static BOOL mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData);
297static BOOL mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData);
298static BOOL mcs_read_domain_mcspdu_header(wLog* log, wStream* s, DomainMCSPDU domainMCSPDU,
299 UINT16* length, DomainMCSPDU* actual);
300
301static int mcs_initialize_client_channels(rdpMcs* mcs, const rdpSettings* settings)
302{
303 if (!mcs || !settings)
304 return -1;
305
306 mcs->channelCount = freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount);
307
308 if (mcs->channelCount > mcs->channelMaxCount)
309 mcs->channelCount = mcs->channelMaxCount;
310
311 ZeroMemory(mcs->channels, sizeof(rdpMcsChannel) * mcs->channelMaxCount);
312
313 for (UINT32 index = 0; index < mcs->channelCount; index++)
314 {
315 const CHANNEL_DEF* defchannel =
316 freerdp_settings_get_pointer_array(settings, FreeRDP_ChannelDefArray, index);
317 rdpMcsChannel* cur = &mcs->channels[index];
318 WINPR_ASSERT(defchannel);
319 CopyMemory(cur->Name, defchannel->name, CHANNEL_NAME_LEN);
320 cur->options = defchannel->options;
321 }
322
323 return 0;
324}
325
335BOOL mcs_read_domain_mcspdu_header(wLog* log, wStream* s, DomainMCSPDU domainMCSPDU, UINT16* length,
336 DomainMCSPDU* actual)
337{
338 UINT16 li = 0;
339 BYTE choice = 0;
340
341 if (actual)
342 *actual = DomainMCSPDU_invalid;
343
344 WINPR_ASSERT(s);
345 WINPR_ASSERT(domainMCSPDU);
346 WINPR_ASSERT(length);
347
348 if (!tpkt_read_header(s, length))
349 return FALSE;
350
351 if (!tpdu_read_data(s, &li, *length))
352 return FALSE;
353
354 if (!per_read_choice(s, &choice))
355 return FALSE;
356
357 const BYTE val = choice >> 2;
358 const DomainMCSPDU MCSPDU =
359 (val > DomainMCSPDU_enum_length) ? DomainMCSPDU_invalid : (DomainMCSPDU)(val);
360 if (actual)
361 *actual = MCSPDU;
362
363 if (domainMCSPDU != MCSPDU)
364 {
365 WLog_Print(log, WLOG_ERROR, "Expected MCS %s, got %s", mcs_domain_pdu_string(domainMCSPDU),
366 mcs_domain_pdu_string(MCSPDU));
367 return FALSE;
368 }
369
370 return TRUE;
371}
372
380BOOL mcs_write_domain_mcspdu_header(wStream* s, DomainMCSPDU domainMCSPDU, UINT16 length,
381 BYTE options)
382{
383 WINPR_ASSERT(s);
384 WINPR_ASSERT((options & ~0x03) == 0);
385 WINPR_ASSERT((domainMCSPDU & ~0x3F) == 0);
386
387 if (!tpkt_write_header(s, length))
388 return FALSE;
389 if (!tpdu_write_data(s))
390 return FALSE;
391 return per_write_choice(s, (BYTE)((domainMCSPDU << 2) | options));
392}
393
403static BOOL mcs_init_domain_parameters(DomainParameters* domainParameters, UINT32 maxChannelIds,
404 UINT32 maxUserIds, UINT32 maxTokenIds, UINT32 maxMCSPDUsize)
405{
406 if (!domainParameters)
407 return FALSE;
408
409 domainParameters->maxChannelIds = maxChannelIds;
410 domainParameters->maxUserIds = maxUserIds;
411 domainParameters->maxTokenIds = maxTokenIds;
412 domainParameters->maxMCSPDUsize = maxMCSPDUsize;
413 domainParameters->numPriorities = 1;
414 domainParameters->minThroughput = 0;
415 domainParameters->maxHeight = 1;
416 domainParameters->protocolVersion = 2;
417 return TRUE;
418}
419
426static BOOL mcs_read_domain_parameters(wStream* s, DomainParameters* domainParameters)
427{
428 size_t length = 0;
429
430 if (!s || !domainParameters)
431 return FALSE;
432
433 return ber_read_sequence_tag(s, &length) &&
434 ber_read_integer(s, &(domainParameters->maxChannelIds)) &&
435 ber_read_integer(s, &(domainParameters->maxUserIds)) &&
436 ber_read_integer(s, &(domainParameters->maxTokenIds)) &&
437 ber_read_integer(s, &(domainParameters->numPriorities)) &&
438 ber_read_integer(s, &(domainParameters->minThroughput)) &&
439 ber_read_integer(s, &(domainParameters->maxHeight)) &&
440 ber_read_integer(s, &(domainParameters->maxMCSPDUsize)) &&
441 ber_read_integer(s, &(domainParameters->protocolVersion));
442}
443
450static BOOL mcs_write_domain_parameters(wLog* log, wStream* s, DomainParameters* domainParameters)
451{
452 BOOL rc = FALSE;
453 size_t length = 0;
454
455 if (!s || !domainParameters)
456 return FALSE;
457
458 wStream* tmps = Stream_New(nullptr, Stream_Capacity(s));
459
460 if (!tmps)
461 {
462 WLog_Print(log, WLOG_ERROR, "Stream_New failed!");
463 return FALSE;
464 }
465
466 if (!ber_write_integer(tmps, domainParameters->maxChannelIds))
467 goto fail;
468 if (!ber_write_integer(tmps, domainParameters->maxUserIds))
469 goto fail;
470 if (!ber_write_integer(tmps, domainParameters->maxTokenIds))
471 goto fail;
472 if (!ber_write_integer(tmps, domainParameters->numPriorities))
473 goto fail;
474 if (!ber_write_integer(tmps, domainParameters->minThroughput))
475 goto fail;
476 if (!ber_write_integer(tmps, domainParameters->maxHeight))
477 goto fail;
478 if (!ber_write_integer(tmps, domainParameters->maxMCSPDUsize))
479 goto fail;
480 if (!ber_write_integer(tmps, domainParameters->protocolVersion))
481 goto fail;
482 length = Stream_GetPosition(tmps);
483 if (!ber_write_sequence_tag(s, length))
484 goto fail;
485 Stream_Write(s, Stream_Buffer(tmps), length);
486
487 rc = TRUE;
488fail:
489 Stream_Free(tmps, TRUE);
490 return rc;
491}
492
493#ifdef DEBUG_MCS
499static void mcs_print_domain_parameters(DomainParameters* domainParameters)
500{
501 WLog_INFO(TAG, "DomainParameters {");
502
503 if (domainParameters)
504 {
505 WLog_INFO(TAG, "\tmaxChannelIds:%" PRIu32 "", domainParameters->maxChannelIds);
506 WLog_INFO(TAG, "\tmaxUserIds:%" PRIu32 "", domainParameters->maxUserIds);
507 WLog_INFO(TAG, "\tmaxTokenIds:%" PRIu32 "", domainParameters->maxTokenIds);
508 WLog_INFO(TAG, "\tnumPriorities:%" PRIu32 "", domainParameters->numPriorities);
509 WLog_INFO(TAG, "\tminThroughput:%" PRIu32 "", domainParameters->minThroughput);
510 WLog_INFO(TAG, "\tmaxHeight:%" PRIu32 "", domainParameters->maxHeight);
511 WLog_INFO(TAG, "\tmaxMCSPDUsize:%" PRIu32 "", domainParameters->maxMCSPDUsize);
512 WLog_INFO(TAG, "\tprotocolVersion:%" PRIu32 "", domainParameters->protocolVersion);
513 }
514 else
515 WLog_INFO(TAG, "\tdomainParameters=%p", domainParameters);
516
517 WLog_INFO(TAG, "}");
518}
519#endif
520
531BOOL mcs_merge_domain_parameters(wLog* log, DomainParameters* targetParameters,
532 DomainParameters* minimumParameters,
533 DomainParameters* maximumParameters,
534 DomainParameters* pOutParameters)
535{
536 /* maxChannelIds */
537 if (!targetParameters || !minimumParameters || !maximumParameters || !pOutParameters)
538 return FALSE;
539
540 if (targetParameters->maxChannelIds >= 4)
541 {
542 pOutParameters->maxChannelIds = targetParameters->maxChannelIds;
543 }
544 else if (maximumParameters->maxChannelIds >= 4)
545 {
546 pOutParameters->maxChannelIds = 4;
547 }
548 else
549 {
550 WLog_Print(log, WLOG_ERROR, "invalid maxChannelIds [%" PRIu32 ", %" PRIu32 "]",
551 targetParameters->maxChannelIds, maximumParameters->maxChannelIds);
552 return FALSE;
553 }
554
555 /* maxUserIds */
556
557 if (targetParameters->maxUserIds >= 3)
558 {
559 pOutParameters->maxUserIds = targetParameters->maxUserIds;
560 }
561 else if (maximumParameters->maxUserIds >= 3)
562 {
563 pOutParameters->maxUserIds = 3;
564 }
565 else
566 {
567 WLog_Print(log, WLOG_ERROR, "invalid maxUserIds [%" PRIu32 ", %" PRIu32 "]",
568 targetParameters->maxUserIds, maximumParameters->maxUserIds);
569 return FALSE;
570 }
571
572 /* maxTokenIds */
573 pOutParameters->maxTokenIds = targetParameters->maxTokenIds;
574
575 /* numPriorities */
576
577 if (minimumParameters->numPriorities <= 1)
578 {
579 pOutParameters->numPriorities = 1;
580 }
581 else
582 {
583 WLog_Print(log, WLOG_ERROR, "invalid numPriorities [%" PRIu32 "]",
584 maximumParameters->numPriorities);
585 return FALSE;
586 }
587
588 /* minThroughput */
589 pOutParameters->minThroughput = targetParameters->minThroughput;
590
591 /* maxHeight */
592
593 if ((targetParameters->maxHeight == 1) || (minimumParameters->maxHeight <= 1))
594 {
595 pOutParameters->maxHeight = 1;
596 }
597 else
598 {
599 WLog_Print(log, WLOG_ERROR, "invalid maxHeight [%" PRIu32 ", %" PRIu32 "]",
600 targetParameters->maxHeight, minimumParameters->maxHeight);
601 return FALSE;
602 }
603
604 /* maxMCSPDUsize */
605
606 if (targetParameters->maxMCSPDUsize >= 1024)
607 {
608 if (targetParameters->maxMCSPDUsize <= 65528)
609 {
610 pOutParameters->maxMCSPDUsize = targetParameters->maxMCSPDUsize;
611 }
612 else if ((minimumParameters->maxMCSPDUsize >= 124) &&
613 (minimumParameters->maxMCSPDUsize <= 65528))
614 {
615 pOutParameters->maxMCSPDUsize = 65528;
616 }
617 else
618 {
619 WLog_Print(log, WLOG_ERROR, "invalid maxMCSPDUsize [%" PRIu32 ", %" PRIu32 "]",
620 targetParameters->maxMCSPDUsize, minimumParameters->maxMCSPDUsize);
621 return FALSE;
622 }
623 }
624 else
625 {
626 if (maximumParameters->maxMCSPDUsize >= 124)
627 {
628 pOutParameters->maxMCSPDUsize = maximumParameters->maxMCSPDUsize;
629 }
630 else
631 {
632 WLog_Print(log, WLOG_ERROR, "invalid maxMCSPDUsize [%" PRIu32 "]",
633 maximumParameters->maxMCSPDUsize);
634 return FALSE;
635 }
636 }
637
638 /* protocolVersion */
639
640 if ((targetParameters->protocolVersion == 2) ||
641 ((minimumParameters->protocolVersion <= 2) && (maximumParameters->protocolVersion >= 2)))
642 {
643 pOutParameters->protocolVersion = 2;
644 }
645 else
646 {
647 WLog_Print(log, WLOG_ERROR,
648 "invalid protocolVersion [%" PRIu32 ", %" PRIu32 ", %" PRIu32 "]",
649 targetParameters->protocolVersion, minimumParameters->protocolVersion,
650 maximumParameters->protocolVersion);
651 return FALSE;
652 }
653
654 return TRUE;
655}
656
664BOOL mcs_recv_connect_initial(rdpMcs* mcs, wStream* s)
665{
666 UINT16 li = 0;
667 size_t length = 0;
668 BOOL upwardFlag = FALSE;
669 UINT16 tlength = 0;
670
671 WINPR_ASSERT(mcs);
672 WINPR_ASSERT(s);
673
674 if (!tpkt_read_header(s, &tlength))
675 return FALSE;
676
677 if (!tpdu_read_data(s, &li, tlength))
678 return FALSE;
679
680 if (!ber_read_application_tag(s, MCS_TYPE_CONNECT_INITIAL, &length))
681 return FALSE;
682
683 /* callingDomainSelector (OCTET_STRING) */
684 if (!ber_read_octet_string_tag(s, &length) ||
685 (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, length)))
686 return FALSE;
687
688 Stream_Seek(s, length);
689
690 /* calledDomainSelector (OCTET_STRING) */
691 if (!ber_read_octet_string_tag(s, &length) ||
692 (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, length)))
693 return FALSE;
694
695 Stream_Seek(s, length);
696
697 /* upwardFlag (BOOLEAN) */
698 if (!ber_read_BOOL(s, &upwardFlag))
699 return FALSE;
700
701 /* targetParameters (DomainParameters) */
702 if (!mcs_read_domain_parameters(s, &mcs->targetParameters))
703 return FALSE;
704
705 /* minimumParameters (DomainParameters) */
706 if (!mcs_read_domain_parameters(s, &mcs->minimumParameters))
707 return FALSE;
708
709 /* maximumParameters (DomainParameters) */
710 if (!mcs_read_domain_parameters(s, &mcs->maximumParameters))
711 return FALSE;
712
713 if (!ber_read_octet_string_tag(s, &length) ||
714 (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, length)))
715 return FALSE;
716
717 if (!gcc_read_conference_create_request(s, mcs))
718 return FALSE;
719
720 if (!mcs_merge_domain_parameters(mcs->log, &mcs->targetParameters, &mcs->minimumParameters,
721 &mcs->maximumParameters, &mcs->domainParameters))
722 return FALSE;
723
724 return tpkt_ensure_stream_consumed(mcs->log, s, tlength);
725}
726
735BOOL mcs_write_connect_initial(wStream* s, rdpMcs* mcs, wStream* userData)
736{
737 size_t length = 0;
738 wStream* tmps = nullptr;
739 BOOL ret = FALSE;
740
741 if (!s || !mcs || !userData)
742 return FALSE;
743
744 tmps = Stream_New(nullptr, Stream_Capacity(s));
745
746 if (!tmps)
747 {
748 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
749 return FALSE;
750 }
751
752 /* callingDomainSelector (OCTET_STRING) */
753 if (!ber_write_octet_string(tmps, callingDomainSelector, sizeof(callingDomainSelector)))
754 goto out;
755 /* calledDomainSelector (OCTET_STRING) */
756 if (!ber_write_octet_string(tmps, calledDomainSelector, sizeof(calledDomainSelector)))
757 goto out;
758 /* upwardFlag (BOOLEAN) */
759 ber_write_BOOL(tmps, TRUE);
760
761 /* targetParameters (DomainParameters) */
762 if (!mcs_write_domain_parameters(mcs->log, tmps, &mcs->targetParameters))
763 goto out;
764
765 /* minimumParameters (DomainParameters) */
766 if (!mcs_write_domain_parameters(mcs->log, tmps, &mcs->minimumParameters))
767 goto out;
768
769 /* maximumParameters (DomainParameters) */
770 if (!mcs_write_domain_parameters(mcs->log, tmps, &mcs->maximumParameters))
771 goto out;
772
773 /* userData (OCTET_STRING) */
774 if (!ber_write_octet_string(tmps, Stream_Buffer(userData), Stream_GetPosition(userData)))
775 goto out;
776 length = Stream_GetPosition(tmps);
777 /* Connect-Initial (APPLICATION 101, IMPLICIT SEQUENCE) */
778 ber_write_application_tag(s, MCS_TYPE_CONNECT_INITIAL, length);
779 Stream_Write(s, Stream_Buffer(tmps), length);
780 ret = TRUE;
781out:
782 Stream_Free(tmps, TRUE);
783 return ret;
784}
785
796BOOL mcs_write_connect_response(wStream* s, rdpMcs* mcs, wStream* userData)
797{
798 size_t length = 0;
799 wStream* tmps = nullptr;
800 BOOL ret = FALSE;
801
802 if (!s || !mcs || !userData)
803 return FALSE;
804
805 tmps = Stream_New(nullptr, Stream_Capacity(s));
806
807 if (!tmps)
808 {
809 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
810 return FALSE;
811 }
812
813 ber_write_enumerated(tmps, 0, MCS_Result_enum_length);
814 if (!ber_write_integer(tmps, 0)) /* calledConnectId */
815 goto out;
816
817 if (!mcs_write_domain_parameters(mcs->log, tmps, &(mcs->domainParameters)))
818 goto out;
819
820 /* userData (OCTET_STRING) */
821 if (!ber_write_octet_string(tmps, Stream_Buffer(userData), Stream_GetPosition(userData)))
822 goto out;
823 length = Stream_GetPosition(tmps);
824 ber_write_application_tag(s, MCS_TYPE_CONNECT_RESPONSE, length);
825 Stream_Write(s, Stream_Buffer(tmps), length);
826 ret = TRUE;
827out:
828 Stream_Free(tmps, TRUE);
829 return ret;
830}
831
838static BOOL mcs_send_connect_initial(rdpMcs* mcs)
839{
840 int status = -1;
841 size_t length = 0;
842 wStream* s = nullptr;
843 size_t bm = 0;
844 size_t em = 0;
845 wStream* gcc_CCrq = nullptr;
846
847 if (!mcs || !mcs->context)
848 return FALSE;
849
850 mcs_initialize_client_channels(mcs, mcs->context->settings);
851 wStream* client_data = Stream_New(nullptr, 512);
852
853 if (!client_data)
854 {
855 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
856 return FALSE;
857 }
858
859 if (!gcc_write_client_data_blocks(client_data, mcs))
860 goto out;
861 gcc_CCrq = Stream_New(nullptr, 1024);
862
863 if (!gcc_CCrq)
864 {
865 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
866 goto out;
867 }
868
869 if (!gcc_write_conference_create_request(gcc_CCrq, client_data))
870 goto out;
871 length = Stream_GetPosition(gcc_CCrq) + 7;
872 s = Stream_New(nullptr, 1024 + length);
873
874 if (!s)
875 {
876 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
877 goto out;
878 }
879
880 bm = Stream_GetPosition(s);
881 Stream_Seek(s, 7);
882
883 if (!mcs_write_connect_initial(s, mcs, gcc_CCrq))
884 {
885 WLog_Print(mcs->log, WLOG_ERROR, "mcs_write_connect_initial failed!");
886 goto out;
887 }
888
889 em = Stream_GetPosition(s);
890 length = (em - bm);
891 if (length > UINT16_MAX)
892 goto out;
893 if (!Stream_SetPosition(s, bm))
894 goto out;
895 if (!tpkt_write_header(s, (UINT16)length))
896 goto out;
897 if (!tpdu_write_data(s))
898 goto out;
899 if (!Stream_SetPosition(s, em))
900 goto out;
901 Stream_SealLength(s);
902
903 {
904 rdpTransport* transport = freerdp_get_transport(mcs->context);
905 status = transport_write(transport, s);
906 }
907
908out:
909 Stream_Free(s, TRUE);
910 Stream_Free(gcc_CCrq, TRUE);
911 Stream_Free(client_data, TRUE);
912 return ((status >= 0));
913}
914
921BOOL mcs_recv_connect_response(rdpMcs* mcs, wStream* s)
922{
923 size_t length = 0;
924 UINT16 tlength = 0;
925 BYTE result = 0;
926 UINT16 li = 0;
927 UINT32 calledConnectId = 0;
928
929 if (!mcs || !s)
930 return FALSE;
931
932 if (!tpkt_read_header(s, &tlength))
933 return FALSE;
934
935 if (!tpdu_read_data(s, &li, tlength))
936 return FALSE;
937
938 if (!ber_read_application_tag(s, MCS_TYPE_CONNECT_RESPONSE, &length) ||
939 !ber_read_enumerated(s, &result, MCS_Result_enum_length) ||
940 !ber_read_integer(s, &calledConnectId) ||
941 !mcs_read_domain_parameters(s, &(mcs->domainParameters)) ||
942 !ber_read_octet_string_tag(s, &length))
943 {
944 return FALSE;
945 }
946
947 if (!gcc_read_conference_create_response(s, mcs))
948 {
949 WLog_Print(mcs->log, WLOG_ERROR, "gcc_read_conference_create_response failed");
950 return FALSE;
951 }
952
953 return tpkt_ensure_stream_consumed(mcs->log, s, tlength);
954}
955
962BOOL mcs_send_connect_response(rdpMcs* mcs)
963{
964 size_t length = 0;
965 int status = -1;
966 wStream* s = nullptr;
967 size_t bm = 0;
968 size_t em = 0;
969 wStream* gcc_CCrsp = nullptr;
970
971 if (!mcs)
972 return FALSE;
973
974 wStream* server_data = Stream_New(nullptr, 512);
975
976 if (!server_data)
977 {
978 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
979 return FALSE;
980 }
981
982 if (!gcc_write_server_data_blocks(server_data, mcs))
983 goto out;
984
985 gcc_CCrsp = Stream_New(nullptr, 512 + Stream_Capacity(server_data));
986
987 if (!gcc_CCrsp)
988 {
989 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
990 goto out;
991 }
992
993 if (!gcc_write_conference_create_response(gcc_CCrsp, server_data))
994 goto out;
995 length = Stream_GetPosition(gcc_CCrsp) + 7;
996 s = Stream_New(nullptr, length + 1024);
997
998 if (!s)
999 {
1000 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1001 goto out;
1002 }
1003
1004 bm = Stream_GetPosition(s);
1005 Stream_Seek(s, 7);
1006
1007 if (!mcs_write_connect_response(s, mcs, gcc_CCrsp))
1008 goto out;
1009
1010 em = Stream_GetPosition(s);
1011 length = (em - bm);
1012 if (length > UINT16_MAX)
1013 goto out;
1014 if (!Stream_SetPosition(s, bm))
1015 goto out;
1016 if (!tpkt_write_header(s, (UINT16)length))
1017 goto out;
1018 if (!tpdu_write_data(s))
1019 goto out;
1020 if (!Stream_SetPosition(s, em))
1021 goto out;
1022 Stream_SealLength(s);
1023
1024 {
1025 rdpTransport* transport = freerdp_get_transport(mcs->context);
1026 status = transport_write(transport, s);
1027 }
1028
1029out:
1030 Stream_Free(s, TRUE);
1031 Stream_Free(gcc_CCrsp, TRUE);
1032 Stream_Free(server_data, TRUE);
1033 return (status >= 0);
1034}
1035
1043BOOL mcs_recv_erect_domain_request(rdpMcs* mcs, wStream* s)
1044{
1045 UINT16 length = 0;
1046 UINT32 subHeight = 0;
1047 UINT32 subInterval = 0;
1048
1049 WINPR_ASSERT(mcs);
1050 WINPR_ASSERT(s);
1051
1052 if (!mcs_read_domain_mcspdu_header(mcs->log, s, DomainMCSPDU_ErectDomainRequest, &length,
1053 nullptr))
1054 return FALSE;
1055
1056 if (!per_read_integer(s, &subHeight)) /* subHeight (INTEGER) */
1057 return FALSE;
1058
1059 if (!per_read_integer(s, &subInterval)) /* subInterval (INTEGER) */
1060 return FALSE;
1061
1062 return tpkt_ensure_stream_consumed(mcs->log, s, length);
1063}
1064
1071BOOL mcs_send_erect_domain_request(rdpMcs* mcs)
1072{
1073 int status = -1;
1074 UINT16 length = 12;
1075
1076 if (!mcs)
1077 return FALSE;
1078
1079 wStream* s = Stream_New(nullptr, length);
1080
1081 if (!s)
1082 {
1083 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1084 return FALSE;
1085 }
1086
1087 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ErectDomainRequest, length, 0))
1088 goto out;
1089 if (!per_write_integer(s, 0)) /* subHeight (INTEGER) */
1090 goto out;
1091 if (!per_write_integer(s, 0)) /* subInterval (INTEGER) */
1092 goto out;
1093 Stream_SealLength(s);
1094
1095 rdpTransport* transport = freerdp_get_transport(mcs->context);
1096 status = transport_write(transport, s);
1097out:
1098 Stream_Free(s, TRUE);
1099 return (status >= 0);
1100}
1101
1109BOOL mcs_recv_attach_user_request(rdpMcs* mcs, wStream* s)
1110{
1111 UINT16 length = 0;
1112
1113 if (!mcs || !s)
1114 return FALSE;
1115
1116 if (!mcs_read_domain_mcspdu_header(mcs->log, s, DomainMCSPDU_AttachUserRequest, &length,
1117 nullptr))
1118 return FALSE;
1119 return tpkt_ensure_stream_consumed(mcs->log, s, length);
1120}
1121
1128BOOL mcs_send_attach_user_request(rdpMcs* mcs)
1129{
1130 int status = -1;
1131 UINT16 length = 8;
1132
1133 if (!mcs)
1134 return FALSE;
1135
1136 wStream* s = Stream_New(nullptr, length);
1137
1138 if (!s)
1139 {
1140 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1141 return FALSE;
1142 }
1143
1144 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserRequest, length, 0))
1145 goto fail;
1146
1147 Stream_SealLength(s);
1148
1149 rdpTransport* transport = freerdp_get_transport(mcs->context);
1150 status = transport_write(transport, s);
1151
1152fail:
1153 Stream_Free(s, TRUE);
1154 return (status >= 0);
1155}
1156
1163BOOL mcs_recv_attach_user_confirm(rdpMcs* mcs, wStream* s)
1164{
1165 BYTE result = 0;
1166 UINT16 length = 0;
1167
1168 if (!mcs || !s)
1169 return FALSE;
1170
1171 if (!mcs_read_domain_mcspdu_header(mcs->log, s, DomainMCSPDU_AttachUserConfirm, &length,
1172 nullptr))
1173 return FALSE;
1174 if (!per_read_enumerated(s, &result, MCS_Result_enum_length)) /* result */
1175 return FALSE;
1176 if (!per_read_integer16(s, &(mcs->userId), MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
1177 return FALSE;
1178 return tpkt_ensure_stream_consumed(mcs->log, s, length);
1179}
1180
1187BOOL mcs_send_attach_user_confirm(rdpMcs* mcs)
1188{
1189 int status = -1;
1190 UINT16 length = 11;
1191
1192 if (!mcs)
1193 return FALSE;
1194
1195 wStream* s = Stream_New(nullptr, length);
1196
1197 if (!s)
1198 {
1199 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1200 return FALSE;
1201 }
1202
1203 mcs->userId = mcs->baseChannelId++;
1204 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_AttachUserConfirm, length, 2))
1205 goto out;
1206 if (!per_write_enumerated(s, 0, MCS_Result_enum_length)) /* result */
1207 goto out;
1208 if (!per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
1209 goto out;
1210 Stream_SealLength(s);
1211
1212 rdpTransport* transport = freerdp_get_transport(mcs->context);
1213 status = transport_write(transport, s);
1214out:
1215 Stream_Free(s, TRUE);
1216 return (status >= 0);
1217}
1218
1226BOOL mcs_recv_channel_join_request(rdpMcs* mcs, const rdpSettings* settings, wStream* s,
1227 UINT16* channelId)
1228{
1229 UINT16 length = 0;
1230 UINT16 userId = 0;
1231
1232 if (!mcs || !s || !channelId)
1233 return FALSE;
1234
1235 if (!mcs_read_domain_mcspdu_header(mcs->log, s, DomainMCSPDU_ChannelJoinRequest, &length,
1236 nullptr))
1237 return FALSE;
1238
1239 if (!per_read_integer16(s, &userId, MCS_BASE_CHANNEL_ID))
1240 return FALSE;
1241 if (userId != mcs->userId)
1242 {
1243 if (freerdp_settings_get_bool(settings, FreeRDP_TransportDumpReplay))
1244 mcs->userId = userId;
1245 else
1246 return FALSE;
1247 }
1248 if (!per_read_integer16(s, channelId, 0))
1249 return FALSE;
1250
1251 return tpkt_ensure_stream_consumed(mcs->log, s, length);
1252}
1253
1264BOOL mcs_send_channel_join_request(rdpMcs* mcs, UINT16 channelId)
1265{
1266 int status = -1;
1267 UINT16 length = 12;
1268
1269 WINPR_ASSERT(mcs);
1270
1271 wStream* s = Stream_New(nullptr, length);
1272
1273 if (!s)
1274 {
1275 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1276 return FALSE;
1277 }
1278
1279 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinRequest, length, 0))
1280 goto out;
1281 if (!per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID))
1282 goto out;
1283 if (!per_write_integer16(s, channelId, 0))
1284 goto out;
1285 Stream_SealLength(s);
1286
1287 rdpTransport* transport = freerdp_get_transport(mcs->context);
1288 status = transport_write(transport, s);
1289
1290out:
1291 Stream_Free(s, TRUE);
1292 return (status >= 0);
1293}
1294
1301BOOL mcs_recv_channel_join_confirm(rdpMcs* mcs, wStream* s, UINT16* channelId)
1302{
1303 UINT16 length = 0;
1304 BYTE result = 0;
1305 UINT16 initiator = 0;
1306 UINT16 requested = 0;
1307
1308 WINPR_ASSERT(mcs);
1309 WINPR_ASSERT(channelId);
1310
1311 if (!mcs_read_domain_mcspdu_header(mcs->log, s, DomainMCSPDU_ChannelJoinConfirm, &length,
1312 nullptr))
1313 return FALSE;
1314
1315 if (!per_read_enumerated(s, &result, MCS_Result_enum_length)) /* result */
1316 return FALSE;
1317 if (!per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
1318 return FALSE;
1319 if (!per_read_integer16(s, &requested, 0)) /* requested (ChannelId) */
1320 return FALSE;
1321 if (!per_read_integer16(s, channelId, 0)) /* channelId */
1322 return FALSE;
1323 return tpkt_ensure_stream_consumed(mcs->log, s, length);
1324}
1325
1332BOOL mcs_send_channel_join_confirm(rdpMcs* mcs, UINT16 channelId)
1333{
1334 int status = -1;
1335 UINT16 length = 15;
1336
1337 if (!mcs)
1338 return FALSE;
1339
1340 wStream* s = Stream_New(nullptr, length);
1341
1342 if (!s)
1343 {
1344 WLog_Print(mcs->log, WLOG_ERROR, "Stream_New failed!");
1345 return FALSE;
1346 }
1347
1348 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_ChannelJoinConfirm, length, 2))
1349 goto fail;
1350 if (!per_write_enumerated(s, 0, MCS_Result_enum_length)) /* result */
1351 goto fail;
1352 if (!per_write_integer16(s, mcs->userId, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
1353 goto fail;
1354 if (!per_write_integer16(s, channelId, 0)) /* requested (ChannelId) */
1355 goto fail;
1356 if (!per_write_integer16(s, channelId, 0)) /* channelId */
1357 goto fail;
1358 Stream_SealLength(s);
1359
1360 {
1361 rdpTransport* transport = freerdp_get_transport(mcs->context);
1362 status = transport_write(transport, s);
1363 }
1364
1365fail:
1366 Stream_Free(s, TRUE);
1367 return (status >= 0);
1368}
1369
1375BOOL mcs_recv_disconnect_provider_ultimatum(WINPR_ATTR_UNUSED rdpMcs* mcs, wStream* s, int* reason)
1376{
1377 BYTE b1 = 0;
1378 BYTE b2 = 0;
1379
1380 WINPR_ASSERT(mcs);
1381 WINPR_ASSERT(s);
1382 WINPR_ASSERT(reason);
1383
1384 /*
1385 * http://msdn.microsoft.com/en-us/library/cc240872.aspx:
1386 *
1387 * PER encoded (ALIGNED variant of BASIC-PER) PDU contents:
1388 * 21 80
1389 *
1390 * 0x21:
1391 * 0 - --\
1392 * 0 - |
1393 * 1 - | CHOICE: From DomainMCSPDU select disconnectProviderUltimatum (8)
1394 * 0 - | of type DisconnectProviderUltimatum
1395 * 0 - |
1396 * 0 - --/
1397 * 0 - --\
1398 * 1 - |
1399 * | DisconnectProviderUltimatum::reason = rn-user-requested (3)
1400 * 0x80: |
1401 * 1 - --/
1402 * 0 - padding
1403 * 0 - padding
1404 * 0 - padding
1405 * 0 - padding
1406 * 0 - padding
1407 * 0 - padding
1408 * 0 - padding
1409 */
1410
1411 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 1))
1412 return FALSE;
1413
1414 Stream_Rewind_UINT8(s);
1415 Stream_Read_UINT8(s, b1);
1416 Stream_Read_UINT8(s, b2);
1417 *reason = ((b1 & 0x01) << 1) | (b2 >> 7);
1418 return TRUE;
1419}
1420
1426BOOL mcs_send_disconnect_provider_ultimatum(rdpMcs* mcs, enum Disconnect_Ultimatum reason)
1427{
1428 int status = -1;
1429 UINT16 length = 9;
1430
1431 WINPR_ASSERT(mcs);
1432
1433 wStream* s = Stream_New(nullptr, length);
1434
1435 if (!s)
1436 goto fail;
1437
1438 if (!mcs_write_domain_mcspdu_header(s, DomainMCSPDU_DisconnectProviderUltimatum, length, 1))
1439 goto fail;
1440
1441 if (!per_write_enumerated(s, 0x80, WINPR_ASSERTING_INT_CAST(BYTE, reason)))
1442 goto fail;
1443
1444 {
1445 rdpTransport* transport = freerdp_get_transport(mcs->context);
1446 status = transport_write(transport, s);
1447 }
1448
1449fail:
1450 WLog_Print(mcs->log, WLOG_DEBUG, "sending DisconnectProviderUltimatum(%s)",
1451 freerdp_disconnect_reason_string((int)reason));
1452 Stream_Free(s, TRUE);
1453 return (status >= 0);
1454}
1455
1456BOOL mcs_client_begin(rdpMcs* mcs)
1457{
1458 if (!mcs || !mcs->context)
1459 return FALSE;
1460
1461 /* First transition state, we need this to trigger session recording */
1462 if (!mcs_send_connect_initial(mcs))
1463 {
1464 freerdp_set_last_error_if_not(mcs->context, FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR);
1465
1466 WLog_Print(mcs->log, WLOG_ERROR, "Error: unable to send MCS Connect Initial");
1467 return FALSE;
1468 }
1469
1470 return TRUE;
1471}
1472
1479rdpMcs* mcs_new(rdpContext* context)
1480{
1481 rdpMcs* mcs = (rdpMcs*)calloc(1, sizeof(rdpMcs));
1482
1483 if (!mcs)
1484 return nullptr;
1485 mcs->log = WLog_Get(MCS_TAG);
1486 WINPR_ASSERT(mcs->log);
1487
1488 mcs->context = context;
1489 mcs_init_domain_parameters(&mcs->targetParameters, 34, 2, 0, 0xFFFF);
1490 mcs_init_domain_parameters(&mcs->minimumParameters, 1, 1, 1, 0x420);
1491 mcs_init_domain_parameters(&mcs->maximumParameters, 0xFFFF, 0xFC17, 0xFFFF, 0xFFFF);
1492 mcs_init_domain_parameters(&mcs->domainParameters, 0, 0, 0, 0xFFFF);
1493 mcs->channelCount = 0;
1494 mcs->channelMaxCount = CHANNEL_MAX_COUNT;
1495 mcs->baseChannelId = MCS_GLOBAL_CHANNEL_ID + 1;
1496 mcs->channels = (rdpMcsChannel*)calloc(mcs->channelMaxCount, sizeof(rdpMcsChannel));
1497
1498 if (!mcs->channels)
1499 goto out_free;
1500
1501 return mcs;
1502out_free:
1503 free(mcs);
1504 return nullptr;
1505}
1506
1512void mcs_free(rdpMcs* mcs)
1513{
1514 if (mcs)
1515 {
1516 free(mcs->channels);
1517 free(mcs);
1518 }
1519}
1520
1521BOOL mcs_server_apply_to_settings(const rdpMcs* mcs, rdpSettings* settings)
1522{
1523 BOOL rc = FALSE;
1524
1525 WINPR_ASSERT(mcs);
1526 WINPR_ASSERT(settings);
1527
1528 if (!freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, mcs->channelCount))
1529 goto fail;
1530
1531 for (UINT32 x = 0; x < mcs->channelCount; x++)
1532 {
1533 const rdpMcsChannel* current = &mcs->channels[x];
1534 CHANNEL_DEF def = WINPR_C_ARRAY_INIT;
1535 def.options = current->options;
1536 memcpy(def.name, current->Name, sizeof(def.name));
1537 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_ChannelDefArray, x, &def))
1538 goto fail;
1539 }
1540
1541 rc = TRUE;
1542fail:
1543 if (!rc)
1544 WLog_Print(mcs->log, WLOG_WARN, "failed to apply settings");
1545
1546 return rc;
1547}
freerdp_settings_set_uint32
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.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
CHANNEL_DEF
Definition wtsapi.h:78