FreeRDP
Loading...
Searching...
No Matches
gcc.c
1
24#include <freerdp/config.h>
25
26#include "settings.h"
27
28#include <winpr/crt.h>
29#include <winpr/crypto.h>
30#include <winpr/assert.h>
31#include <winpr/cast.h>
32
33#include <freerdp/log.h>
34#include <freerdp/utils/string.h>
35#include <freerdp/crypto/certificate.h>
36
37#include "utils.h"
38#include "gcc.h"
39#include "nego.h"
40
41#include "../crypto/certificate.h"
42
43typedef enum
44{
45 HIGH_COLOR_4BPP = 0x04,
46 HIGH_COLOR_8BPP = 0x08,
47 HIGH_COLOR_15BPP = 0x0F,
48 HIGH_COLOR_16BPP = 0x10,
49 HIGH_COLOR_24BPP = 0x18,
50} HIGH_COLOR_DEPTH;
51
52static const char* HighColorToString(HIGH_COLOR_DEPTH color)
53{
54 switch (color)
55 {
56 case HIGH_COLOR_4BPP:
57 return "HIGH_COLOR_4BPP";
58 case HIGH_COLOR_8BPP:
59 return "HIGH_COLOR_8BPP";
60 case HIGH_COLOR_15BPP:
61 return "HIGH_COLOR_15BPP";
62 case HIGH_COLOR_16BPP:
63 return "HIGH_COLOR_16BPP";
64 case HIGH_COLOR_24BPP:
65 return "HIGH_COLOR_24BPP";
66 default:
67 return "HIGH_COLOR_UNKNOWN";
68 }
69}
70
71static HIGH_COLOR_DEPTH ColorDepthToHighColor(UINT32 bpp)
72{
73 switch (bpp)
74 {
75 case 4:
76 return HIGH_COLOR_4BPP;
77 case 8:
78 return HIGH_COLOR_8BPP;
79 case 15:
80 return HIGH_COLOR_15BPP;
81 case 16:
82 return HIGH_COLOR_16BPP;
83 default:
84 return HIGH_COLOR_24BPP;
85 }
86}
87
88static char* gcc_block_type_string(UINT16 type, char* buffer, size_t size);
89static BOOL gcc_read_client_cluster_data(wStream* s, rdpMcs* mcs);
90static BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs);
91static BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, UINT16 length);
92static BOOL gcc_read_server_data_blocks(wStream* s, rdpMcs* mcs, UINT16 length);
93static BOOL gcc_read_user_data_header(wLog* log, wStream* s, UINT16* type, UINT16* length);
94static BOOL gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length);
95
96static BOOL gcc_write_client_core_data(wStream* s, const rdpMcs* mcs);
97static BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs);
98static BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs);
99static BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs);
100static BOOL gcc_write_client_security_data(wStream* s, const rdpMcs* mcs);
101static BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs);
102static BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs);
103static BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs);
104static BOOL gcc_write_client_network_data(wStream* s, const rdpMcs* mcs);
105static BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs);
106static BOOL gcc_write_server_network_data(wStream* s, const rdpMcs* mcs);
107static BOOL gcc_write_client_cluster_data(wStream* s, const rdpMcs* mcs);
108static BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs);
109static BOOL gcc_write_client_monitor_data(wStream* s, const rdpMcs* mcs);
110static BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs);
111static BOOL gcc_write_client_monitor_extended_data(wStream* s, const rdpMcs* mcs);
112static BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs);
113static BOOL gcc_write_client_message_channel_data(wStream* s, const rdpMcs* mcs);
114static BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs);
115static BOOL gcc_write_server_message_channel_data(wStream* s, const rdpMcs* mcs);
116static BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs);
117static BOOL gcc_write_client_multitransport_channel_data(wStream* s, const rdpMcs* mcs);
118static BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs);
119static BOOL gcc_write_server_multitransport_channel_data(wStream* s, const rdpMcs* mcs);
120
121static rdpSettings* mcs_get_settings(rdpMcs* mcs)
122{
123 WINPR_ASSERT(mcs);
124 WINPR_ASSERT(mcs->context);
125
126 return mcs->context->settings;
127}
128
129static const rdpSettings* mcs_get_const_settings(const rdpMcs* mcs)
130{
131 WINPR_ASSERT(mcs);
132 WINPR_ASSERT(mcs->context);
133
134 return mcs->context->settings;
135}
136
137static char* rdp_early_server_caps_string(UINT32 flags, char* buffer, size_t size)
138{
139 char msg[32] = WINPR_C_ARRAY_INIT;
140 const UINT32 mask = RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1 | RNS_UD_SC_DYNAMIC_DST_SUPPORTED |
141 RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2 | RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED;
142 const UINT32 unknown = flags & (~mask);
143
144 if (flags & RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1)
145 winpr_str_append("RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1", buffer, size, "|");
146 if (flags & RNS_UD_SC_DYNAMIC_DST_SUPPORTED)
147 winpr_str_append("RNS_UD_SC_DYNAMIC_DST_SUPPORTED", buffer, size, "|");
148 if (flags & RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2)
149 winpr_str_append("RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2", buffer, size, "|");
150 if (flags & RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED)
151 winpr_str_append("RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED", buffer, size, "|");
152
153 if (unknown != 0)
154 {
155 (void)_snprintf(msg, sizeof(msg), "RNS_UD_SC_UNKNOWN[0x%08" PRIx32 "]", unknown);
156 winpr_str_append(msg, buffer, size, "|");
157 }
158 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", flags);
159 winpr_str_append(msg, buffer, size, "|");
160 return buffer;
161}
162
163static const char* rdp_early_client_caps_string(UINT32 flags, char* buffer, size_t size)
164{
165 char msg[32] = WINPR_C_ARRAY_INIT;
166 const UINT32 mask = RNS_UD_CS_SUPPORT_ERRINFO_PDU | RNS_UD_CS_WANT_32BPP_SESSION |
167 RNS_UD_CS_SUPPORT_STATUSINFO_PDU | RNS_UD_CS_STRONG_ASYMMETRIC_KEYS |
168 RNS_UD_CS_RELATIVE_MOUSE_INPUT | RNS_UD_CS_VALID_CONNECTION_TYPE |
169 RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU |
170 RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT |
171 RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL | RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE |
172 RNS_UD_CS_SUPPORT_HEARTBEAT_PDU | RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN;
173 const UINT32 unknown = flags & (~mask);
174
175 if (flags & RNS_UD_CS_SUPPORT_ERRINFO_PDU)
176 winpr_str_append("RNS_UD_CS_SUPPORT_ERRINFO_PDU", buffer, size, "|");
177 if (flags & RNS_UD_CS_WANT_32BPP_SESSION)
178 winpr_str_append("RNS_UD_CS_WANT_32BPP_SESSION", buffer, size, "|");
179 if (flags & RNS_UD_CS_SUPPORT_STATUSINFO_PDU)
180 winpr_str_append("RNS_UD_CS_SUPPORT_STATUSINFO_PDU", buffer, size, "|");
181 if (flags & RNS_UD_CS_STRONG_ASYMMETRIC_KEYS)
182 winpr_str_append("RNS_UD_CS_STRONG_ASYMMETRIC_KEYS", buffer, size, "|");
183 if (flags & RNS_UD_CS_RELATIVE_MOUSE_INPUT)
184 winpr_str_append("RNS_UD_CS_RELATIVE_MOUSE_INPUT", buffer, size, "|");
185 if (flags & RNS_UD_CS_VALID_CONNECTION_TYPE)
186 winpr_str_append("RNS_UD_CS_VALID_CONNECTION_TYPE", buffer, size, "|");
187 if (flags & RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU)
188 winpr_str_append("RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU", buffer, size, "|");
189 if (flags & RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT)
190 winpr_str_append("RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT", buffer, size, "|");
191 if (flags & RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL)
192 winpr_str_append("RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL", buffer, size, "|");
193 if (flags & RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE)
194 winpr_str_append("RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE", buffer, size, "|");
195 if (flags & RNS_UD_CS_SUPPORT_HEARTBEAT_PDU)
196 winpr_str_append("RNS_UD_CS_SUPPORT_HEARTBEAT_PDU", buffer, size, "|");
197 if (flags & RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN)
198 winpr_str_append("RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN", buffer, size, "|");
199
200 if (unknown != 0)
201 {
202 (void)_snprintf(msg, sizeof(msg), "RNS_UD_CS_UNKNOWN[0x%08" PRIx32 "]", unknown);
203 winpr_str_append(msg, buffer, size, "|");
204 }
205 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", flags);
206 winpr_str_append(msg, buffer, size, "|");
207 return buffer;
208}
209
210static DWORD rdp_version_common(wLog* log, DWORD serverVersion, DWORD clientVersion)
211{
212 DWORD version = MIN(serverVersion, clientVersion);
213
214 switch (version)
215 {
216 case RDP_VERSION_4:
217 case RDP_VERSION_5_PLUS:
218 case RDP_VERSION_10_0:
219 case RDP_VERSION_10_1:
220 case RDP_VERSION_10_2:
221 case RDP_VERSION_10_3:
222 case RDP_VERSION_10_4:
223 case RDP_VERSION_10_5:
224 case RDP_VERSION_10_6:
225 case RDP_VERSION_10_7:
226 case RDP_VERSION_10_8:
227 case RDP_VERSION_10_9:
228 case RDP_VERSION_10_10:
229 case RDP_VERSION_10_11:
230 case RDP_VERSION_10_12:
231 return version;
232
233 default:
234 WLog_Print(log, WLOG_ERROR,
235 "Invalid client [%" PRIu32 "] and server [%" PRIu32 "] versions",
236 serverVersion, clientVersion);
237 return version;
238 }
239}
240
335/*
336 * OID = 0.0.20.124.0.1
337 * { itu-t(0) recommendation(0) t(20) t124(124) version(0) 1 }
338 * v.1 of ITU-T Recommendation T.124 (Feb 1998): "Generic Conference Control"
339 */
340static const BYTE t124_02_98_oid[6] = { 0, 0, 20, 124, 0, 1 };
341
342static const BYTE h221_cs_key[4] = { 'D', 'u', 'c', 'a' };
343static const BYTE h221_sc_key[4] = { 'M', 'c', 'D', 'n' };
344
355BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs)
356{
357 UINT16 length = 0;
358 BYTE choice = 0;
359 BYTE number = 0;
360 BYTE selection = 0;
361
362 WINPR_ASSERT(s);
363 WINPR_ASSERT(mcs);
364 /* ConnectData */
365 if (!per_read_choice(s, &choice))
366 return FALSE;
367
368 if (!per_read_object_identifier(s, t124_02_98_oid))
369 return FALSE;
370
371 /* ConnectData::connectPDU (OCTET_STRING) */
372 if (!per_read_length(s, &length))
373 return FALSE;
374
375 /* ConnectGCCPDU */
376 if (!per_read_choice(s, &choice))
377 return FALSE;
378
379 if (!per_read_selection(s, &selection))
380 return FALSE;
381
382 /* ConferenceCreateRequest::conferenceName */
383 if (!per_read_numeric_string(s, 1)) /* ConferenceName::numeric */
384 return FALSE;
385
386 if (!per_read_padding(s, 1)) /* padding */
387 return FALSE;
388
389 /* UserData (SET OF SEQUENCE) */
390 if (!per_read_number_of_sets(s, &number) || number != 1) /* one set of UserData */
391 return FALSE;
392
393 if (!per_read_choice(s, &choice) ||
394 choice != 0xC0) /* UserData::value present + select h221NonStandard (1) */
395 return FALSE;
396
397 /* h221NonStandard */
398 if (!per_read_octet_string(s, h221_cs_key, 4,
399 4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */
400 return FALSE;
401
402 /* userData::value (OCTET_STRING) */
403 if (!per_read_length(s, &length))
404 return FALSE;
405
406 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, length))
407 return FALSE;
408
409 if (!gcc_read_client_data_blocks(s, mcs, length))
410 return FALSE;
411
412 return TRUE;
413}
414
425BOOL gcc_write_conference_create_request(wStream* s, wStream* userData)
426{
427 WINPR_ASSERT(s);
428 WINPR_ASSERT(userData);
429 /* ConnectData */
430 if (!per_write_choice(s, 0)) /* From Key select object (0) of type OBJECT_IDENTIFIER */
431 return FALSE;
432 if (!per_write_object_identifier(s, t124_02_98_oid)) /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */
433 return FALSE;
434 /* ConnectData::connectPDU (OCTET_STRING) */
435 const size_t pos = Stream_GetPosition(userData);
436 WINPR_ASSERT(pos <= UINT16_MAX - 14);
437 if (!per_write_length(s, (UINT16)pos + 14)) /* connectPDU length */
438 return FALSE;
439 /* ConnectGCCPDU */
440 if (!per_write_choice(s, 0)) /* From ConnectGCCPDU select conferenceCreateRequest (0) of type
441 ConferenceCreateRequest */
442 return FALSE;
443 if (!per_write_selection(s, 0x08)) /* select optional userData from ConferenceCreateRequest */
444 return FALSE;
445 /* ConferenceCreateRequest::conferenceName */
446 if (!per_write_numeric_string(s, (BYTE*)"1", 1, 1)) /* ConferenceName::numeric */
447 return FALSE;
448 if (!per_write_padding(s, 1)) /* padding */
449 return FALSE;
450 /* UserData (SET OF SEQUENCE) */
451 if (!per_write_number_of_sets(s, 1)) /* one set of UserData */
452 return FALSE;
453 if (!per_write_choice(s, 0xC0)) /* UserData::value present + select h221NonStandard (1) */
454 return FALSE;
455 /* h221NonStandard */
456 if (!per_write_octet_string(s, h221_cs_key, 4,
457 4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */
458 return FALSE;
459 /* userData::value (OCTET_STRING) */
460 const size_t upos = Stream_GetPosition(userData);
461 WINPR_ASSERT(upos <= UINT16_MAX);
462 return per_write_octet_string(s, Stream_Buffer(userData), (UINT16)upos,
463 0); /* array of client data blocks */
464}
465
466BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs)
467{
468 UINT16 length = 0;
469 UINT32 tag = 0;
470 UINT16 nodeID = 0;
471 BYTE result = 0;
472 BYTE choice = 0;
473 BYTE number = 0;
474 WINPR_ASSERT(s);
475 WINPR_ASSERT(mcs);
476 /* ConnectData */
477 if (!per_read_choice(s, &choice) || !per_read_object_identifier(s, t124_02_98_oid))
478 return FALSE;
479
480 /* ConnectData::connectPDU (OCTET_STRING) */
481 if (!per_read_length(s, &length))
482 return FALSE;
483
484 /* ConnectGCCPDU */
485 if (!per_read_choice(s, &choice))
486 return FALSE;
487
488 /* ConferenceCreateResponse::nodeID (UserID) */
489 if (!per_read_integer16(s, &nodeID, 1001))
490 return FALSE;
491
492 /* ConferenceCreateResponse::tag (INTEGER) */
493 if (!per_read_integer(s, &tag))
494 return FALSE;
495
496 /* ConferenceCreateResponse::result (ENUMERATED) */
497 if (!per_read_enumerated(s, &result, MCS_Result_enum_length))
498 return FALSE;
499
500 /* number of UserData sets */
501 if (!per_read_number_of_sets(s, &number))
502 return FALSE;
503
504 /* UserData::value present + select h221NonStandard (1) */
505 if (!per_read_choice(s, &choice))
506 return FALSE;
507
508 /* h221NonStandard */
509 if (!per_read_octet_string(s, h221_sc_key, 4,
510 4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */
511 return FALSE;
512
513 /* userData (OCTET_STRING) */
514 if (!per_read_length(s, &length))
515 return FALSE;
516
517 if (!gcc_read_server_data_blocks(s, mcs, length))
518 {
519 WLog_Print(mcs->log, WLOG_ERROR,
520 "gcc_read_conference_create_response: gcc_read_server_data_blocks failed");
521 return FALSE;
522 }
523
524 return TRUE;
525}
526
527BOOL gcc_write_conference_create_response(wStream* s, wStream* userData)
528{
529 WINPR_ASSERT(s);
530 WINPR_ASSERT(userData);
531 /* ConnectData */
532 if (!per_write_choice(s, 0))
533 return FALSE;
534 if (!per_write_object_identifier(s, t124_02_98_oid))
535 return FALSE;
536 /* ConnectData::connectPDU (OCTET_STRING) */
537 /* This length MUST be ignored by the client according to [MS-RDPBCGR] */
538 if (!per_write_length(s, 0x2A))
539 return FALSE;
540 /* ConnectGCCPDU */
541 if (!per_write_choice(s, 0x14))
542 return FALSE;
543 /* ConferenceCreateResponse::nodeID (UserID) */
544 if (!per_write_integer16(s, 0x79F3, 1001))
545 return FALSE;
546 /* ConferenceCreateResponse::tag (INTEGER) */
547 if (!per_write_integer(s, 1))
548 return FALSE;
549 /* ConferenceCreateResponse::result (ENUMERATED) */
550 if (!per_write_enumerated(s, 0, MCS_Result_enum_length))
551 return FALSE;
552 /* number of UserData sets */
553 if (!per_write_number_of_sets(s, 1))
554 return FALSE;
555 /* UserData::value present + select h221NonStandard (1) */
556 if (!per_write_choice(s, 0xC0))
557 return FALSE;
558 /* h221NonStandard */
559 if (!per_write_octet_string(s, h221_sc_key, 4,
560 4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */
561 return FALSE;
562 /* userData (OCTET_STRING) */
563 const size_t pos = Stream_GetPosition(userData);
564 WINPR_ASSERT(pos <= UINT16_MAX);
565 return per_write_octet_string(s, Stream_Buffer(userData), (UINT16)pos,
566 0); /* array of server data blocks */
567}
568
569static BOOL gcc_read_client_unused1_data(wStream* s)
570{
571 return Stream_SafeSeek(s, 2);
572}
573
574BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, UINT16 length)
575{
576 WINPR_ASSERT(s);
577 WINPR_ASSERT(mcs);
578
579 BOOL gotMultitransport = FALSE;
580
581 while (length > 0)
582 {
583 wStream sbuffer = WINPR_C_ARRAY_INIT;
584 UINT16 type = 0;
585 UINT16 blockLength = 0;
586
587 if (!gcc_read_user_data_header(mcs->log, s, &type, &blockLength))
588 return FALSE;
589
590 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, (size_t)(blockLength - 4)))
591 return FALSE;
592
593 wStream* sub = Stream_StaticConstInit(&sbuffer, Stream_Pointer(s), blockLength - 4);
594 WINPR_ASSERT(sub);
595
596 Stream_Seek(s, blockLength - 4);
597
598 {
599 char buffer[64] = WINPR_C_ARRAY_INIT;
600 WLog_Print(mcs->log, WLOG_TRACE, "Processing block %s",
601 gcc_block_type_string(type, buffer, sizeof(buffer)));
602 }
603 switch (type)
604 {
605 case CS_CORE:
606 if (!gcc_read_client_core_data(sub, mcs))
607 return FALSE;
608
609 break;
610
611 case CS_SECURITY:
612 if (!gcc_read_client_security_data(sub, mcs))
613 return FALSE;
614
615 break;
616
617 case CS_NET:
618 if (!gcc_read_client_network_data(sub, mcs))
619 return FALSE;
620
621 break;
622
623 case CS_CLUSTER:
624 if (!gcc_read_client_cluster_data(sub, mcs))
625 return FALSE;
626
627 break;
628
629 case CS_MONITOR:
630 if (!gcc_read_client_monitor_data(sub, mcs))
631 return FALSE;
632
633 break;
634
635 case CS_MCS_MSGCHANNEL:
636 if (!gcc_read_client_message_channel_data(sub, mcs))
637 return FALSE;
638
639 break;
640
641 case CS_MONITOR_EX:
642 if (!gcc_read_client_monitor_extended_data(sub, mcs))
643 return FALSE;
644
645 break;
646
647 case CS_UNUSED1:
648 if (!gcc_read_client_unused1_data(sub))
649 return FALSE;
650
651 break;
652
653 case 0xC009:
654 case CS_MULTITRANSPORT:
655 gotMultitransport = TRUE;
656 if (!gcc_read_client_multitransport_channel_data(sub, mcs))
657 return FALSE;
658
659 break;
660
661 default:
662 WLog_Print(mcs->log, WLOG_ERROR, "Unknown GCC client data block: 0x%04" PRIX16 "",
663 type);
664 winpr_HexLogDump(mcs->log, WLOG_TRACE, Stream_Pointer(sub),
665 Stream_GetRemainingLength(sub));
666 break;
667 }
668
669 const size_t rem = Stream_GetRemainingLength(sub);
670 if (rem > 0)
671 {
672 char buffer[128] = WINPR_C_ARRAY_INIT;
673 const size_t total = Stream_Length(sub);
674 WLog_Print(mcs->log, WLOG_ERROR,
675 "Error parsing GCC client data block %s: Actual Offset: %" PRIuz
676 " Expected Offset: %" PRIuz,
677 gcc_block_type_string(type, buffer, sizeof(buffer)), total - rem, total);
678 }
679
680 if (blockLength > length)
681 {
682 char buffer[128] = WINPR_C_ARRAY_INIT;
683 WLog_Print(mcs->log, WLOG_ERROR,
684 "Error parsing GCC client data block %s: got blockLength 0x%04" PRIx16
685 ", but only 0x%04" PRIx16 "remaining",
686 gcc_block_type_string(type, buffer, sizeof(buffer)), blockLength, length);
687 length = 0;
688 }
689 else
690 length -= blockLength;
691 }
692
693 if (!gotMultitransport)
694 {
695 rdpSettings* settings = mcs_get_settings(mcs);
696 if (!freerdp_settings_set_bool(settings, FreeRDP_SupportMultitransport, FALSE))
697 return FALSE;
698 if (!freerdp_settings_set_uint32(settings, FreeRDP_MultitransportFlags, 0))
699 return FALSE;
700 }
701 return TRUE;
702}
703
704BOOL gcc_write_client_data_blocks(wStream* s, const rdpMcs* mcs)
705{
706 const rdpSettings* settings = mcs_get_const_settings(mcs);
707
708 WINPR_ASSERT(s);
709 WINPR_ASSERT(settings);
710
711 if (!gcc_write_client_core_data(s, mcs) || !gcc_write_client_cluster_data(s, mcs) ||
712 !gcc_write_client_security_data(s, mcs) || !gcc_write_client_network_data(s, mcs))
713 return FALSE;
714
715 /* extended client data supported */
716
717 if (settings->NegotiationFlags & EXTENDED_CLIENT_DATA_SUPPORTED)
718 {
719 if (settings->UseMultimon && !settings->SpanMonitors)
720 {
721 if (!gcc_write_client_monitor_data(s, mcs) ||
722 !gcc_write_client_monitor_extended_data(s, mcs))
723 return FALSE;
724 }
725
726 if (!gcc_write_client_message_channel_data(s, mcs) ||
727 !gcc_write_client_multitransport_channel_data(s, mcs))
728 return FALSE;
729 }
730 else
731 {
732 if (settings->UseMultimon && !settings->SpanMonitors)
733 {
734 WLog_Print(mcs->log, WLOG_ERROR,
735 "WARNING: true multi monitor support was not advertised by server!");
736
737 if (settings->ForceMultimon)
738 {
739 WLog_Print(mcs->log, WLOG_ERROR,
740 "Sending multi monitor information anyway (may break connectivity!)");
741 if (!gcc_write_client_monitor_data(s, mcs) ||
742 !gcc_write_client_monitor_extended_data(s, mcs))
743 return FALSE;
744 }
745 else
746 {
747 WLog_Print(mcs->log, WLOG_ERROR,
748 "Use /multimon:force to force sending multi monitor information");
749 }
750 }
751 }
752 return TRUE;
753}
754
755char* gcc_block_type_string(UINT16 type, char* buffer, size_t size)
756{
757 switch (type)
758 {
759 case CS_CORE:
760 (void)_snprintf(buffer, size, "CS_CORE [0x%04" PRIx16 "]", type);
761 break;
762 case CS_SECURITY:
763 (void)_snprintf(buffer, size, "CS_SECURITY [0x%04" PRIx16 "]", type);
764 break;
765 case CS_NET:
766 (void)_snprintf(buffer, size, "CS_NET [0x%04" PRIx16 "]", type);
767 break;
768 case CS_CLUSTER:
769 (void)_snprintf(buffer, size, "CS_CLUSTER [0x%04" PRIx16 "]", type);
770 break;
771 case CS_MONITOR:
772 (void)_snprintf(buffer, size, "CS_MONITOR [0x%04" PRIx16 "]", type);
773 break;
774 case CS_MCS_MSGCHANNEL:
775 (void)_snprintf(buffer, size, "CS_MONITOR [0x%04" PRIx16 "]", type);
776 break;
777 case CS_MONITOR_EX:
778 (void)_snprintf(buffer, size, "CS_MONITOR_EX [0x%04" PRIx16 "]", type);
779 break;
780 case CS_UNUSED1:
781 (void)_snprintf(buffer, size, "CS_UNUSED1 [0x%04" PRIx16 "]", type);
782 break;
783 case CS_MULTITRANSPORT:
784 (void)_snprintf(buffer, size, "CS_MONITOR_EX [0x%04" PRIx16 "]", type);
785 break;
786 case SC_CORE:
787 (void)_snprintf(buffer, size, "SC_CORE [0x%04" PRIx16 "]", type);
788 break;
789 case SC_SECURITY:
790 (void)_snprintf(buffer, size, "SC_SECURITY [0x%04" PRIx16 "]", type);
791 break;
792 case SC_NET:
793 (void)_snprintf(buffer, size, "SC_NET [0x%04" PRIx16 "]", type);
794 break;
795 case SC_MCS_MSGCHANNEL:
796 (void)_snprintf(buffer, size, "SC_MCS_MSGCHANNEL [0x%04" PRIx16 "]", type);
797 break;
798 case SC_MULTITRANSPORT:
799 (void)_snprintf(buffer, size, "SC_MULTITRANSPORT [0x%04" PRIx16 "]", type);
800 break;
801 default:
802 (void)_snprintf(buffer, size, "UNKNOWN [0x%04" PRIx16 "]", type);
803 break;
804 }
805 return buffer;
806}
807
808BOOL gcc_read_server_data_blocks(wStream* s, rdpMcs* mcs, UINT16 length)
809{
810 UINT16 type = 0;
811 UINT16 offset = 0;
812 UINT16 blockLength = 0;
813 BYTE* holdp = nullptr;
814
815 WINPR_ASSERT(s);
816 WINPR_ASSERT(mcs);
817
818 while (offset < length)
819 {
820 char buffer[64] = WINPR_C_ARRAY_INIT;
821 size_t rest = 0;
822 wStream subbuffer;
823 wStream* sub = nullptr;
824
825 if (!gcc_read_user_data_header(mcs->log, s, &type, &blockLength))
826 {
827 WLog_Print(mcs->log, WLOG_ERROR,
828 "gcc_read_server_data_blocks: gcc_read_user_data_header failed");
829 return FALSE;
830 }
831 holdp = Stream_Pointer(s);
832 sub = Stream_StaticInit(&subbuffer, holdp, blockLength - 4);
833 if (!Stream_SafeSeek(s, blockLength - 4))
834 {
835 WLog_Print(mcs->log, WLOG_ERROR, "gcc_read_server_data_blocks: stream too short");
836 return FALSE;
837 }
838 offset += blockLength;
839
840 switch (type)
841 {
842 case SC_CORE:
843 if (!gcc_read_server_core_data(sub, mcs))
844 {
845 WLog_Print(mcs->log, WLOG_ERROR,
846 "gcc_read_server_data_blocks: gcc_read_server_core_data failed");
847 return FALSE;
848 }
849
850 break;
851
852 case SC_SECURITY:
853 if (!gcc_read_server_security_data(sub, mcs))
854 return FALSE;
855 break;
856
857 case SC_NET:
858 if (!gcc_read_server_network_data(sub, mcs))
859 {
860 WLog_Print(mcs->log, WLOG_ERROR,
861 "gcc_read_server_data_blocks: gcc_read_server_network_data failed");
862 return FALSE;
863 }
864
865 break;
866
867 case SC_MCS_MSGCHANNEL:
868 if (!gcc_read_server_message_channel_data(sub, mcs))
869 {
870 WLog_Print(
871 mcs->log, WLOG_ERROR,
872 "gcc_read_server_data_blocks: gcc_read_server_message_channel_data failed");
873 return FALSE;
874 }
875
876 break;
877
878 case SC_MULTITRANSPORT:
879 if (!gcc_read_server_multitransport_channel_data(sub, mcs))
880 {
881 WLog_Print(mcs->log, WLOG_ERROR,
882 "gcc_read_server_data_blocks: "
883 "gcc_read_server_multitransport_channel_data failed");
884 return FALSE;
885 }
886
887 break;
888
889 default:
890 WLog_Print(mcs->log, WLOG_ERROR, "gcc_read_server_data_blocks: ignoring type=%s",
891 gcc_block_type_string(type, buffer, sizeof(buffer)));
892 winpr_HexLogDump(mcs->log, WLOG_TRACE, Stream_Pointer(sub),
893 Stream_GetRemainingLength(sub));
894 break;
895 }
896
897 rest = Stream_GetRemainingLength(sub);
898 if (rest > 0)
899 {
900 WLog_Print(mcs->log, WLOG_WARN,
901 "gcc_read_server_data_blocks: ignoring %" PRIuz " bytes with type=%s", rest,
902 gcc_block_type_string(type, buffer, sizeof(buffer)));
903 }
904 }
905
906 return TRUE;
907}
908
909BOOL gcc_write_server_data_blocks(wStream* s, rdpMcs* mcs)
910{
911 WINPR_ASSERT(s);
912 WINPR_ASSERT(mcs);
913
914 if (!gcc_write_server_core_data(s, mcs) || /* serverCoreData */
915 !gcc_write_server_network_data(s, mcs) || /* serverNetworkData */
916 !gcc_write_server_security_data(s, mcs) || /* serverSecurityData */
917 !gcc_write_server_message_channel_data(s, mcs)) /* serverMessageChannelData */
918 return FALSE;
919
920 const rdpSettings* settings = mcs_get_const_settings(mcs);
921 WINPR_ASSERT(settings);
922
923 if (settings->SupportMultitransport && (settings->MultitransportFlags != 0))
924 /* serverMultitransportChannelData */
925 return gcc_write_server_multitransport_channel_data(s, mcs);
926
927 return TRUE;
928}
929
930BOOL gcc_read_user_data_header(wLog* log, wStream* s, UINT16* type, UINT16* length)
931{
932 WINPR_ASSERT(s);
933 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 4))
934 return FALSE;
935
936 Stream_Read_UINT16(s, *type); /* type */
937 Stream_Read_UINT16(s, *length); /* length */
938
939 return !((*length < 4) ||
940 (!Stream_CheckAndLogRequiredLengthWLog(log, s, (size_t)(*length - 4))));
941}
942
954BOOL gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length)
955{
956
957 WINPR_ASSERT(s);
958 if (!Stream_EnsureRemainingCapacity(s, 4ull + length))
959 return FALSE;
960 Stream_Write_UINT16(s, type); /* type */
961 Stream_Write_UINT16(s, length); /* length */
962 return TRUE;
963}
964
965static UINT32 filterAndLogEarlyServerCapabilityFlags(wLog* log, UINT32 flags)
966{
967 const UINT32 mask =
968 (RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1 | RNS_UD_SC_DYNAMIC_DST_SUPPORTED |
969 RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2 | RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED);
970 const UINT32 filtered = flags & mask;
971 const UINT32 unknown = flags & (~mask);
972 if (unknown != 0)
973 {
974 char buffer[256] = WINPR_C_ARRAY_INIT;
975 WLog_Print(log, WLOG_WARN,
976 "TS_UD_SC_CORE::EarlyCapabilityFlags [0x%08" PRIx32 " & 0x%08" PRIx32
977 " --> 0x%08" PRIx32 "] filtering %s, feature not implemented",
978 flags, ~mask, unknown,
979 rdp_early_server_caps_string(unknown, buffer, sizeof(buffer)));
980 }
981 return filtered;
982}
983
984static UINT32 earlyServerCapsFromSettings(wLog* log, const rdpSettings* settings)
985{
986 UINT32 EarlyCapabilityFlags = 0;
987
988 if (settings->SupportEdgeActionV1)
989 EarlyCapabilityFlags |= RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1;
990 if (settings->SupportDynamicTimeZone)
991 EarlyCapabilityFlags |= RNS_UD_SC_DYNAMIC_DST_SUPPORTED;
992 if (settings->SupportEdgeActionV2)
993 EarlyCapabilityFlags |= RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2;
994 if (settings->SupportSkipChannelJoin)
995 EarlyCapabilityFlags |= RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED;
996
997 return filterAndLogEarlyServerCapabilityFlags(log, EarlyCapabilityFlags);
998}
999
1000static UINT16 filterAndLogEarlyClientCapabilityFlags(wLog* log, UINT32 flags)
1001{
1002 const UINT32 mask =
1003 (RNS_UD_CS_SUPPORT_ERRINFO_PDU | RNS_UD_CS_WANT_32BPP_SESSION |
1004 RNS_UD_CS_SUPPORT_STATUSINFO_PDU | RNS_UD_CS_STRONG_ASYMMETRIC_KEYS |
1005 RNS_UD_CS_RELATIVE_MOUSE_INPUT | RNS_UD_CS_VALID_CONNECTION_TYPE |
1006 RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU | RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT |
1007 RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL | RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE |
1008 RNS_UD_CS_SUPPORT_HEARTBEAT_PDU | RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN);
1009 const UINT32 filtered = flags & mask;
1010 const UINT32 unknown = flags & ~mask;
1011 if (unknown != 0)
1012 {
1013 char buffer[256] = WINPR_C_ARRAY_INIT;
1014 WLog_Print(log, WLOG_WARN,
1015 "(TS_UD_CS_CORE)::EarlyCapabilityFlags [0x%08" PRIx32 " & 0x%08" PRIx32
1016 " --> 0x%08" PRIx32 "] filtering %s, feature not implemented",
1017 flags, ~mask, unknown,
1018 rdp_early_client_caps_string(unknown, buffer, sizeof(buffer)));
1019 }
1020
1021 WINPR_ASSERT(filtered <= UINT16_MAX);
1022 return (UINT16)filtered;
1023}
1024
1025static UINT16 earlyClientCapsFromSettings(wLog* log, const rdpSettings* settings)
1026{
1027 UINT32 earlyCapabilityFlags = 0;
1028
1029 WINPR_ASSERT(settings);
1030 if (settings->SupportErrorInfoPdu)
1031 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_ERRINFO_PDU;
1032
1033 if (freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth) == 32)
1034 earlyCapabilityFlags |= RNS_UD_CS_WANT_32BPP_SESSION;
1035
1036 if (settings->SupportStatusInfoPdu)
1037 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_STATUSINFO_PDU;
1038
1039 if (settings->ConnectionType)
1040 earlyCapabilityFlags |= RNS_UD_CS_VALID_CONNECTION_TYPE;
1041
1042 if (settings->SupportMonitorLayoutPdu)
1043 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU;
1044
1045 if (freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect))
1046 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT;
1047
1048 if (settings->SupportGraphicsPipeline)
1049 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL;
1050
1051 if (settings->SupportDynamicTimeZone)
1052 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE;
1053
1054 if (settings->SupportHeartbeatPdu)
1055 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_HEARTBEAT_PDU;
1056
1057 if (settings->SupportAsymetricKeys)
1058 earlyCapabilityFlags |= RNS_UD_CS_STRONG_ASYMMETRIC_KEYS;
1059
1060 if (settings->HasRelativeMouseEvent)
1061 earlyCapabilityFlags |= RNS_UD_CS_RELATIVE_MOUSE_INPUT;
1062
1063 if (settings->SupportSkipChannelJoin)
1064 earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN;
1065
1066 return filterAndLogEarlyClientCapabilityFlags(log, earlyCapabilityFlags);
1067}
1068
1069static BOOL updateEarlyClientCaps(wLog* log, rdpSettings* settings, UINT32 earlyCapabilityFlags,
1070 UINT32 connectionType)
1071{
1072 WINPR_ASSERT(settings);
1073
1074 if (settings->SupportErrorInfoPdu)
1075 settings->SupportErrorInfoPdu = (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_ERRINFO_PDU) != 0;
1076
1077 /* RNS_UD_CS_WANT_32BPP_SESSION is already handled in gcc_read_client_core_data:
1078 *
1079 * it is evaluated in combination with highColorDepth and the server side
1080 * settings to determine the session color depth to use.
1081 */
1082
1083 if (settings->SupportStatusInfoPdu)
1084 settings->SupportStatusInfoPdu =
1085 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_STATUSINFO_PDU) != 0;
1086
1087 if (settings->SupportAsymetricKeys)
1088 settings->SupportAsymetricKeys =
1089 (earlyCapabilityFlags & RNS_UD_CS_STRONG_ASYMMETRIC_KEYS) != 0;
1090
1091 if (settings->HasRelativeMouseEvent)
1092 {
1093 /* [MS-RDPBCGR] 2.2.7.1.5 Pointer Capability Set (TS_POINTER_CAPABILITYSET)
1094 * the flag must be ignored if the RDP version is < 0x00080011 */
1095 if (settings->RdpVersion >= RDP_VERSION_10_12)
1096 {
1097 settings->HasRelativeMouseEvent =
1098 (earlyCapabilityFlags & RNS_UD_CS_RELATIVE_MOUSE_INPUT) != 0;
1099 }
1100 else
1101 settings->HasRelativeMouseEvent = FALSE;
1102 }
1103
1104 if (settings->NetworkAutoDetect)
1105 settings->NetworkAutoDetect =
1106 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_NETCHAR_AUTODETECT) != 0;
1107
1108 if (settings->SupportSkipChannelJoin)
1109 settings->SupportSkipChannelJoin =
1110 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_SKIP_CHANNELJOIN) != 0;
1111
1112 if (settings->SupportMonitorLayoutPdu)
1113 settings->SupportMonitorLayoutPdu =
1114 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_MONITOR_LAYOUT_PDU) != 0;
1115
1116 if (settings->SupportHeartbeatPdu)
1117 settings->SupportHeartbeatPdu =
1118 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_HEARTBEAT_PDU) != 0;
1119
1120 if (settings->SupportGraphicsPipeline)
1121 settings->SupportGraphicsPipeline =
1122 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_DYNVC_GFX_PROTOCOL) != 0;
1123
1124 if (settings->SupportDynamicTimeZone)
1125 settings->SupportDynamicTimeZone =
1126 (earlyCapabilityFlags & RNS_UD_CS_SUPPORT_DYNAMIC_TIME_ZONE) != 0;
1127
1128 if ((earlyCapabilityFlags & RNS_UD_CS_VALID_CONNECTION_TYPE) == 0)
1129 connectionType = 0;
1130 settings->ConnectionType = connectionType;
1131
1132 filterAndLogEarlyClientCapabilityFlags(log, earlyCapabilityFlags);
1133 return TRUE;
1134}
1135
1136static BOOL updateEarlyServerCaps(wLog* log, rdpSettings* settings, UINT32 earlyCapabilityFlags,
1137 WINPR_ATTR_UNUSED UINT32 connectionType)
1138{
1139 WINPR_ASSERT(settings);
1140
1141 settings->SupportEdgeActionV1 = (settings->SupportEdgeActionV1 &&
1142 (earlyCapabilityFlags & RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V1));
1143 settings->SupportDynamicTimeZone = (settings->SupportDynamicTimeZone &&
1144 (earlyCapabilityFlags & RNS_UD_SC_DYNAMIC_DST_SUPPORTED));
1145 settings->SupportEdgeActionV2 = (settings->SupportEdgeActionV2 &&
1146 (earlyCapabilityFlags & RNS_UD_SC_EDGE_ACTIONS_SUPPORTED_V2));
1147 settings->SupportSkipChannelJoin =
1148 (settings->SupportSkipChannelJoin &&
1149 (earlyCapabilityFlags & RNS_UD_SC_SKIP_CHANNELJOIN_SUPPORTED));
1150
1151 filterAndLogEarlyServerCapabilityFlags(log, earlyCapabilityFlags);
1152 return TRUE;
1153}
1154
1164BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs)
1165{
1166 char buffer[2048] = WINPR_C_ARRAY_INIT;
1167 char strbuffer[130] = WINPR_C_ARRAY_INIT;
1168 BYTE connectionType = 0;
1169 UINT32 clientColorDepth = 0;
1170 UINT16 postBeta2ColorDepth = 0;
1171 UINT16 highColorDepth = 0;
1172 rdpSettings* settings = mcs_get_settings(mcs);
1173
1174 WINPR_ASSERT(s);
1175 WINPR_ASSERT(settings);
1176
1177 /* Length of all required fields, until imeFileName */
1178 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 128))
1179 return FALSE;
1180
1181 const UINT32 version = Stream_Get_UINT32(s); /* version (4 bytes) */
1182 settings->RdpVersion = rdp_version_common(mcs->log, version, settings->RdpVersion);
1183 Stream_Read_UINT16(s, settings->DesktopWidth); /* DesktopWidth (2 bytes) */
1184 if (settings->DesktopWidth == 0)
1185 {
1186 WLog_Print(mcs->log, WLOG_ERROR, "Invalid DesktopWidth=0");
1187 return FALSE;
1188 }
1189 Stream_Read_UINT16(s, settings->DesktopHeight); /* DesktopHeight (2 bytes) */
1190 if (settings->DesktopHeight == 0)
1191 {
1192 WLog_Print(mcs->log, WLOG_ERROR, "Invalid DesktopHeight=0");
1193 return FALSE;
1194 }
1195 const UINT16 colorDepth = Stream_Get_UINT16(s); /* ColorDepth (2 bytes) */
1196 Stream_Seek_UINT16(s); /* SASSequence (Secure Access Sequence) (2 bytes) */
1197 Stream_Read_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout (4 bytes) */
1198 Stream_Read_UINT32(s, settings->ClientBuild); /* ClientBuild (4 bytes) */
1199
1200 /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
1201 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, 32 / sizeof(WCHAR), strbuffer,
1202 ARRAYSIZE(strbuffer)) < 0)
1203 {
1204 WLog_Print(mcs->log, WLOG_ERROR, "failed to convert client host name");
1205 return FALSE;
1206 }
1207
1208 if (!freerdp_settings_set_string(settings, FreeRDP_ClientHostname, strbuffer))
1209 return FALSE;
1210
1211 Stream_Read_UINT32(s, settings->KeyboardType); /* KeyboardType (4 bytes) */
1212 Stream_Read_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType (4 bytes) */
1213 Stream_Read_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey (4 bytes) */
1214 freerdp_settings_sanitize_keyboard_type(mcs->log, settings, "TS_UD_CS_CORE");
1215 Stream_Seek(s, 64); /* imeFileName (64 bytes) */
1216
1224 do
1225 {
1226 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1227 break;
1228
1229 postBeta2ColorDepth = Stream_Get_UINT16(s); /* postBeta2ColorDepth (2 bytes) */
1230
1231 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1232 break;
1233
1234 const UINT16 clientProductId = Stream_Get_UINT16(s); /* clientProductID (2 bytes) */
1235
1236 /* [MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::clientProductId (optional)
1237 * should be initialized to 1
1238 */
1239 if (clientProductId != 1)
1240 {
1241 WLog_Print(mcs->log, WLOG_WARN,
1242 "[MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::clientProductId "
1243 "(optional) expected 1, got %" PRIu32,
1244 clientProductId);
1245 }
1246
1247 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1248 break;
1249
1250 const UINT32 serialNumber = Stream_Get_UINT32(s); /* serialNumber (4 bytes) */
1251
1252 /* [MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::serialNumber (optional)
1253 * should be initialized to 0
1254 */
1255 if (serialNumber != 0)
1256 {
1257 WLog_Print(mcs->log, WLOG_WARN,
1258 "[MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::serialNumber "
1259 "(optional) expected 0, got %" PRIu32,
1260 serialNumber);
1261 }
1262
1263 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1264 break;
1265
1266 highColorDepth = Stream_Get_UINT16(s); /* highColorDepth (2 bytes) */
1267
1268 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1269 break;
1270
1271 Stream_Read_UINT16(s, settings->SupportedColorDepths); /* supportedColorDepths (2 bytes) */
1272
1273 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1274 break;
1275
1276 Stream_Read_UINT16(s, settings->EarlyCapabilityFlags); /* earlyCapabilityFlags (2 bytes) */
1277
1278 /* clientDigProductId (64 bytes): Contains a value that uniquely identifies the client */
1279 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 64))
1280 break;
1281
1282 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, 64 / sizeof(WCHAR), strbuffer,
1283 ARRAYSIZE(strbuffer)) < 0)
1284 {
1285 WLog_Print(mcs->log, WLOG_ERROR, "failed to convert the client product identifier");
1286 return FALSE;
1287 }
1288
1289 if (!freerdp_settings_set_string(settings, FreeRDP_ClientProductId, strbuffer))
1290 return FALSE;
1291
1292 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 1))
1293 break;
1294
1295 connectionType = Stream_Get_UINT8(s); /* connectionType (1 byte) */
1296
1297 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 1))
1298 break;
1299
1300 Stream_Seek_UINT8(s); /* pad1octet (1 byte) */
1301
1302 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1303 break;
1304
1305 const UINT32 serverSelectedProtocol =
1306 Stream_Get_UINT32(s); /* serverSelectedProtocol (4 bytes) */
1307
1308 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1309 break;
1310
1311 Stream_Read_UINT32(s, settings->DesktopPhysicalWidth); /* desktopPhysicalWidth (4 bytes) */
1312
1313 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1314 break;
1315
1316 Stream_Read_UINT32(s,
1317 settings->DesktopPhysicalHeight); /* desktopPhysicalHeight (4 bytes) */
1318
1319 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1320 break;
1321
1322 Stream_Read_UINT16(s, settings->DesktopOrientation); /* desktopOrientation (2 bytes) */
1323
1324 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1325 break;
1326
1327 Stream_Read_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor (4 bytes) */
1328
1329 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1330 break;
1331
1332 Stream_Read_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor (4 bytes) */
1333
1334 if (freerdp_settings_get_bool(settings, FreeRDP_TransportDumpReplay))
1335 settings->SelectedProtocol = serverSelectedProtocol;
1336 else if (settings->SelectedProtocol != serverSelectedProtocol)
1337 return FALSE;
1338 } while (0);
1339
1340 if (highColorDepth > 0)
1341 {
1342 if (settings->EarlyCapabilityFlags & RNS_UD_CS_WANT_32BPP_SESSION)
1343 clientColorDepth = 32;
1344 else
1345 clientColorDepth = highColorDepth;
1346 }
1347 else if (postBeta2ColorDepth > 0)
1348 {
1349 switch (postBeta2ColorDepth)
1350 {
1351 case RNS_UD_COLOR_4BPP:
1352 clientColorDepth = 4;
1353 break;
1354
1355 case RNS_UD_COLOR_8BPP:
1356 clientColorDepth = 8;
1357 break;
1358
1359 case RNS_UD_COLOR_16BPP_555:
1360 clientColorDepth = 15;
1361 break;
1362
1363 case RNS_UD_COLOR_16BPP_565:
1364 clientColorDepth = 16;
1365 break;
1366
1367 case RNS_UD_COLOR_24BPP:
1368 clientColorDepth = 24;
1369 break;
1370
1371 default:
1372 return FALSE;
1373 }
1374 }
1375 else
1376 {
1377 switch (colorDepth)
1378 {
1379 case RNS_UD_COLOR_4BPP:
1380 clientColorDepth = 4;
1381 break;
1382
1383 case RNS_UD_COLOR_8BPP:
1384 clientColorDepth = 8;
1385 break;
1386
1387 default:
1388 return FALSE;
1389 }
1390 }
1391
1392 /*
1393 * If we are in server mode, accept client's color depth only if
1394 * it is smaller than ours. This is what Windows server does.
1395 */
1396 if ((clientColorDepth < freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)) ||
1397 !settings->ServerMode)
1398 {
1399 if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, clientColorDepth))
1400 return FALSE;
1401 }
1402
1403 WLog_Print(
1404 mcs->log, WLOG_DEBUG, "Received EarlyCapabilityFlags=%s",
1405 rdp_early_client_caps_string(settings->EarlyCapabilityFlags, buffer, sizeof(buffer)));
1406
1407 return updateEarlyClientCaps(mcs->log, settings, settings->EarlyCapabilityFlags,
1408 connectionType);
1409}
1410
1420BOOL gcc_write_client_core_data(wStream* s, const rdpMcs* mcs)
1421{
1422 char buffer[2048] = WINPR_C_ARRAY_INIT;
1423 char dbuffer[2048] = WINPR_C_ARRAY_INIT;
1424 BYTE connectionType = 0;
1425 HIGH_COLOR_DEPTH highColorDepth = HIGH_COLOR_4BPP;
1426
1427 UINT16 earlyCapabilityFlags = 0;
1428 const rdpSettings* settings = mcs_get_const_settings(mcs);
1429
1430 WINPR_ASSERT(s);
1431 WINPR_ASSERT(settings);
1432
1433 const UINT16 SupportedColorDepths =
1434 freerdp_settings_get_uint16(settings, FreeRDP_SupportedColorDepths);
1435 const UINT32 ColorDepth = freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
1436
1437 if (!gcc_write_user_data_header(s, CS_CORE, 234))
1438 return FALSE;
1439
1440 Stream_Write_UINT32(s, settings->RdpVersion); /* Version */
1441 Stream_Write_UINT16(
1442 s, WINPR_ASSERTING_INT_CAST(uint16_t, settings->DesktopWidth)); /* DesktopWidth */
1443 Stream_Write_UINT16(
1444 s, WINPR_ASSERTING_INT_CAST(uint16_t, settings->DesktopHeight)); /* DesktopHeight */
1445 Stream_Write_UINT16(s,
1446 RNS_UD_COLOR_8BPP); /* ColorDepth, ignored because of postBeta2ColorDepth */
1447 Stream_Write_UINT16(s, RNS_UD_SAS_DEL); /* SASSequence (Secure Access Sequence) */
1448 Stream_Write_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout */
1449 Stream_Write_UINT32(s, settings->ClientBuild); /* ClientBuild */
1450
1451 if (!Stream_EnsureRemainingCapacity(s, 32 + 12 + 64 + 8))
1452 return FALSE;
1453
1454 /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
1455 size_t clientNameLength = 0;
1456 WCHAR* clientName = ConvertUtf8ToWCharAlloc(settings->ClientHostname, &clientNameLength);
1457 if (clientNameLength >= 16)
1458 {
1459 clientNameLength = 16;
1460 clientName[clientNameLength - 1] = 0;
1461 }
1462
1463 Stream_Write(s, clientName, (clientNameLength * 2));
1464 Stream_Zero(s, 32 - (clientNameLength * 2));
1465 free(clientName);
1466 Stream_Write_UINT32(s, settings->KeyboardType); /* KeyboardType */
1467 Stream_Write_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType */
1468 Stream_Write_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey */
1469 Stream_Zero(s, 64); /* imeFileName */
1470 Stream_Write_UINT16(s, RNS_UD_COLOR_8BPP); /* postBeta2ColorDepth */
1471 Stream_Write_UINT16(s, 1); /* clientProductID */
1472 Stream_Write_UINT32(s, 0); /* serialNumber (should be initialized to 0) */
1473 highColorDepth = ColorDepthToHighColor(ColorDepth);
1474 earlyCapabilityFlags = earlyClientCapsFromSettings(mcs->log, settings);
1475
1476 WINPR_ASSERT(settings->ConnectionType <= UINT8_MAX);
1477 connectionType = (UINT8)settings->ConnectionType;
1478
1479 if (!Stream_EnsureRemainingCapacity(s, 6))
1480 return FALSE;
1481
1482 WLog_Print(
1483 mcs->log, WLOG_DEBUG,
1484 "Sending highColorDepth=%s, supportedColorDepths=%s, earlyCapabilityFlags=%s",
1485 HighColorToString(highColorDepth),
1486 freerdp_supported_color_depths_string(SupportedColorDepths, dbuffer, sizeof(dbuffer)),
1487 rdp_early_client_caps_string(earlyCapabilityFlags, buffer, sizeof(buffer)));
1488 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, highColorDepth)); /* highColorDepth */
1489 Stream_Write_UINT16(s, SupportedColorDepths); /* supportedColorDepths */
1490 Stream_Write_UINT16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
1491
1492 if (!Stream_EnsureRemainingCapacity(s, 64 + 24))
1493 return FALSE;
1494
1495 /* clientDigProductId (64 bytes, assume WCHAR, not \0 terminated */
1496 const char* str = freerdp_settings_get_string(settings, FreeRDP_ClientProductId);
1497 if (str)
1498 {
1499 if (Stream_Write_UTF16_String_From_UTF8(s, 32, str, strnlen(str, 32), TRUE) < 0)
1500 return FALSE;
1501 }
1502 else
1503 Stream_Zero(s, 32 * sizeof(WCHAR));
1504
1505 Stream_Write_UINT8(s, connectionType); /* connectionType */
1506 Stream_Write_UINT8(s, 0); /* pad1octet */
1507 Stream_Write_UINT32(s, settings->SelectedProtocol); /* serverSelectedProtocol */
1508 Stream_Write_UINT32(s, settings->DesktopPhysicalWidth); /* desktopPhysicalWidth */
1509 Stream_Write_UINT32(s, settings->DesktopPhysicalHeight); /* desktopPhysicalHeight */
1510 Stream_Write_UINT16(s, settings->DesktopOrientation); /* desktopOrientation */
1511 Stream_Write_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor */
1512 Stream_Write_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor */
1513 return TRUE;
1514}
1515
1516BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs)
1517{
1518 UINT32 serverVersion = 0;
1519 rdpSettings* settings = mcs_get_settings(mcs);
1520
1521 WINPR_ASSERT(s);
1522 WINPR_ASSERT(settings);
1523
1524 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1525 return FALSE;
1526
1527 Stream_Read_UINT32(s, serverVersion); /* version */
1528 settings->RdpVersion = rdp_version_common(mcs->log, serverVersion, settings->RdpVersion);
1529
1530 if (Stream_GetRemainingLength(s) >= 4)
1531 {
1532 Stream_Read_UINT32(s, settings->RequestedProtocols); /* clientRequestedProtocols */
1533 }
1534
1535 if (Stream_GetRemainingLength(s) >= 4)
1536 {
1537 char buffer[2048] = WINPR_C_ARRAY_INIT;
1538
1539 Stream_Read_UINT32(s, settings->EarlyCapabilityFlags); /* earlyCapabilityFlags */
1540 WLog_Print(
1541 mcs->log, WLOG_DEBUG, "Received EarlyCapabilityFlags=%s",
1542 rdp_early_client_caps_string(settings->EarlyCapabilityFlags, buffer, sizeof(buffer)));
1543 }
1544
1545 return updateEarlyServerCaps(mcs->log, settings, settings->EarlyCapabilityFlags,
1546 settings->ConnectionType);
1547}
1548
1549/* TODO: This function modifies rdpMcs
1550 * TODO: Split this out of this function
1551 */
1552BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs)
1553{
1554 const rdpSettings* settings = mcs_get_const_settings(mcs);
1555
1556 WINPR_ASSERT(s);
1557 WINPR_ASSERT(settings);
1558
1559 if (!gcc_write_user_data_header(s, SC_CORE, 16))
1560 return FALSE;
1561
1562 const UINT32 EarlyCapabilityFlags = earlyServerCapsFromSettings(mcs->log, settings);
1563 Stream_Write_UINT32(s, settings->RdpVersion); /* version (4 bytes) */
1564 Stream_Write_UINT32(s, settings->RequestedProtocols); /* clientRequestedProtocols (4 bytes) */
1565 Stream_Write_UINT32(s, EarlyCapabilityFlags); /* earlyCapabilityFlags (4 bytes) */
1566 return TRUE;
1567}
1568
1578BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs)
1579{
1580 rdpSettings* settings = mcs_get_settings(mcs);
1581
1582 WINPR_ASSERT(s);
1583 WINPR_ASSERT(settings);
1584
1585 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1586 return FALSE;
1587
1588 if (settings->UseRdpSecurityLayer)
1589 {
1590 Stream_Read_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
1591
1592 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1593 Stream_Read_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
1594 else
1595 Stream_Seek(s, 4);
1596 }
1597 else
1598 {
1599 Stream_Seek(s, 8);
1600 }
1601
1602 return TRUE;
1603}
1604
1614BOOL gcc_write_client_security_data(wStream* s, const rdpMcs* mcs)
1615{
1616 const rdpSettings* settings = mcs_get_const_settings(mcs);
1617
1618 WINPR_ASSERT(s);
1619 WINPR_ASSERT(settings);
1620
1621 if (!gcc_write_user_data_header(s, CS_SECURITY, 12))
1622 return FALSE;
1623
1624 if (settings->UseRdpSecurityLayer)
1625 {
1626 Stream_Write_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
1627 Stream_Write_UINT32(s, 0); /* extEncryptionMethods */
1628 }
1629 else
1630 {
1631 /* French locale, disable encryption */
1632 Stream_Write_UINT32(s, 0); /* encryptionMethods */
1633 Stream_Write_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
1634 }
1635 return TRUE;
1636}
1637
1638BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs)
1639{
1640 BOOL validCryptoConfig = FALSE;
1641 UINT32 EncryptionMethod = 0;
1642 UINT32 EncryptionLevel = 0;
1643 rdpSettings* settings = mcs_get_settings(mcs);
1644
1645 WINPR_ASSERT(s);
1646 WINPR_ASSERT(settings);
1647
1648 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1649 return FALSE;
1650
1651 Stream_Read_UINT32(s, EncryptionMethod); /* encryptionMethod */
1652 Stream_Read_UINT32(s, EncryptionLevel); /* encryptionLevel */
1653
1654 /* Only accept valid/known encryption methods */
1655 switch (EncryptionMethod)
1656 {
1657 case ENCRYPTION_METHOD_NONE:
1658 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: NONE");
1659 break;
1660
1661 case ENCRYPTION_METHOD_40BIT:
1662 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 40BIT");
1663 break;
1664
1665 case ENCRYPTION_METHOD_56BIT:
1666 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 56BIT");
1667 break;
1668
1669 case ENCRYPTION_METHOD_128BIT:
1670 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 128BIT");
1671 break;
1672
1673 case ENCRYPTION_METHOD_FIPS:
1674 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: FIPS");
1675 break;
1676
1677 default:
1678 WLog_Print(mcs->log, WLOG_ERROR, "Received unknown encryption method %08" PRIX32 "",
1679 EncryptionMethod);
1680 return FALSE;
1681 }
1682
1683 if (settings->UseRdpSecurityLayer && (EncryptionMethod != ENCRYPTION_METHOD_NONE) &&
1684 !(settings->EncryptionMethods & EncryptionMethod))
1685 {
1686 WLog_Print(mcs->log, WLOG_WARN,
1687 "Server uses non-advertised encryption method 0x%08" PRIX32 "",
1688 EncryptionMethod);
1689 /* FIXME: Should we return FALSE; in this case ?? */
1690 }
1691
1692 settings->EncryptionMethods = EncryptionMethod;
1693 settings->EncryptionLevel = EncryptionLevel;
1694 /* Verify encryption level/method combinations according to MS-RDPBCGR Section 5.3.2 */
1695 switch (settings->EncryptionLevel)
1696 {
1697 case ENCRYPTION_LEVEL_NONE:
1698 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1699 {
1700 validCryptoConfig = TRUE;
1701 }
1702
1703 break;
1704
1705 case ENCRYPTION_LEVEL_FIPS:
1706 if (settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1707 {
1708 validCryptoConfig = TRUE;
1709 }
1710
1711 break;
1712
1713 case ENCRYPTION_LEVEL_LOW:
1714 case ENCRYPTION_LEVEL_HIGH:
1715 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
1716 if (settings->EncryptionMethods == ENCRYPTION_METHOD_40BIT ||
1717 settings->EncryptionMethods == ENCRYPTION_METHOD_56BIT ||
1718 settings->EncryptionMethods == ENCRYPTION_METHOD_128BIT ||
1719 settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1720 {
1721 validCryptoConfig = TRUE;
1722 }
1723
1724 break;
1725
1726 default:
1727 WLog_Print(mcs->log, WLOG_ERROR, "Received unknown encryption level 0x%08" PRIX32 "",
1728 settings->EncryptionLevel);
1729 }
1730
1731 if (!validCryptoConfig)
1732 {
1733 WLog_Print(mcs->log, WLOG_ERROR,
1734 "Received invalid cryptographic configuration (level=0x%08" PRIX32
1735 " method=0x%08" PRIX32 ")",
1736 settings->EncryptionLevel, settings->EncryptionMethods);
1737 return FALSE;
1738 }
1739
1740 if (settings->EncryptionLevel == ENCRYPTION_LEVEL_NONE)
1741 {
1742 /* serverRandomLen and serverCertLen must not be present */
1743 settings->UseRdpSecurityLayer = FALSE;
1744 return TRUE;
1745 }
1746
1747 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1748 return FALSE;
1749
1750 Stream_Read_UINT32(s, settings->ServerRandomLength); /* serverRandomLen */
1751 Stream_Read_UINT32(s, settings->ServerCertificateLength); /* serverCertLen */
1752
1753 if ((settings->ServerRandomLength == 0) || (settings->ServerCertificateLength == 0))
1754 {
1755 WLog_Print(mcs->log, WLOG_ERROR,
1756 "Invalid ServerRandom (length=%" PRIu32 ") or ServerCertificate (length=%" PRIu32
1757 ")",
1758 settings->ServerRandomLength, settings->ServerCertificateLength);
1759 return FALSE;
1760 }
1761
1762 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, settings->ServerRandomLength))
1763 return FALSE;
1764
1765 /* serverRandom */
1766 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr,
1767 settings->ServerRandomLength))
1768 goto fail;
1769
1770 Stream_Read(s, settings->ServerRandom, settings->ServerRandomLength);
1771
1772 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, settings->ServerCertificateLength))
1773 goto fail;
1774
1775 /* serverCertificate */
1776 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr,
1777 settings->ServerCertificateLength))
1778 goto fail;
1779
1780 Stream_Read(s, settings->ServerCertificate, settings->ServerCertificateLength);
1781
1782 {
1783 const BYTE* data = settings->ServerCertificate;
1784 const uint32_t length = settings->ServerCertificateLength;
1785
1786 if (!freerdp_certificate_read_server_cert(settings->RdpServerCertificate, data, length))
1787 goto fail;
1788 }
1789 return TRUE;
1790fail:
1791 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, 0))
1792 WLog_Print(
1793 mcs->log, WLOG_ERROR,
1794 "freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, 0) failed");
1795 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr, 0))
1796 WLog_Print(mcs->log, WLOG_ERROR,
1797 "freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr, "
1798 "0) failed");
1799 return FALSE;
1800}
1801
1802static BOOL gcc_update_server_random(rdpSettings* settings)
1803{
1804 const size_t length = 32;
1805 WINPR_ASSERT(settings);
1806 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, length))
1807 return FALSE;
1808 BYTE* data = freerdp_settings_get_pointer_writable(settings, FreeRDP_ServerRandom);
1809 if (!data)
1810 return FALSE;
1811 return winpr_RAND(data, length) >= 0;
1812}
1813
1814/* TODO: This function does manipulate data in rdpMcs
1815 * TODO: Split this out of this function
1816 */
1817BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs)
1818{
1819 if (!gcc_update_server_random(mcs_get_settings(mcs)))
1820 return FALSE;
1821
1822 const rdpSettings* settings = mcs_get_const_settings(mcs);
1823
1824 WINPR_ASSERT(s);
1825 WINPR_ASSERT(settings);
1826
1827 const size_t posHeader = Stream_GetPosition(s);
1828 if (!gcc_write_user_data_header(s, SC_SECURITY, 12))
1829 return FALSE;
1830
1831 Stream_Write_UINT32(s, settings->EncryptionMethods); /* encryptionMethod */
1832 Stream_Write_UINT32(s, settings->EncryptionLevel); /* encryptionLevel */
1833
1834 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1835 return TRUE;
1836
1837 if (!Stream_EnsureRemainingCapacity(s, sizeof(UINT32) + settings->ServerRandomLength))
1838 return FALSE;
1839 Stream_Write_UINT32(s, settings->ServerRandomLength); /* serverRandomLen */
1840 const size_t posCertLen = Stream_GetPosition(s);
1841 Stream_Seek_UINT32(s); /* serverCertLen */
1842 Stream_Write(s, settings->ServerRandom, settings->ServerRandomLength);
1843
1844 const SSIZE_T len = freerdp_certificate_write_server_cert(
1845 settings->RdpServerCertificate, CERT_TEMPORARILY_ISSUED | CERT_CHAIN_VERSION_1, s);
1846 if (len < 0)
1847 return FALSE;
1848 const size_t end = Stream_GetPosition(s);
1849
1850 WINPR_ASSERT(end >= posHeader);
1851 const size_t diff = end - posHeader;
1852 WINPR_ASSERT(diff <= UINT16_MAX);
1853 if (!Stream_SetPosition(s, posHeader))
1854 return FALSE;
1855 if (!gcc_write_user_data_header(s, SC_SECURITY, (UINT16)diff))
1856 return FALSE;
1857 if (!Stream_SetPosition(s, posCertLen))
1858 return FALSE;
1859 WINPR_ASSERT(len <= UINT32_MAX);
1860 Stream_Write_UINT32(s, (UINT32)len);
1861 return Stream_SetPosition(s, end);
1862}
1863
1874BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs)
1875{
1876 WINPR_ASSERT(s);
1877 WINPR_ASSERT(mcs);
1878
1879 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1880 return FALSE;
1881
1882 Stream_Read_UINT32(s, mcs->channelCount); /* channelCount */
1883
1884 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, mcs->channelCount, 12ull))
1885 return FALSE;
1886
1887 if (mcs->channelCount > CHANNEL_MAX_COUNT)
1888 {
1889 WLog_Print(mcs->log, WLOG_ERROR, "rdpMcs::channelCount %" PRIu32 " > maximum %d",
1890 mcs->channelCount, CHANNEL_MAX_COUNT);
1891 return FALSE;
1892 }
1893
1894 /* channelDefArray */
1895 for (UINT32 i = 0; i < mcs->channelCount; i++)
1896 {
1903 rdpMcsChannel* channel = &mcs->channels[i];
1904 Stream_Read(s, channel->Name, CHANNEL_NAME_LEN + 1); /* name (8 bytes) */
1905
1906 if (!memchr(channel->Name, 0, CHANNEL_NAME_LEN + 1))
1907 {
1908 WLog_Print(
1909 mcs->log, WLOG_ERROR,
1910 "protocol violation: received a static channel name with missing null-termination");
1911 return FALSE;
1912 }
1913
1914 Stream_Read_UINT32(s, channel->options); /* options (4 bytes) */
1915 channel->ChannelId = mcs->baseChannelId++;
1916 }
1917
1918 return TRUE;
1919}
1920
1930BOOL gcc_write_client_network_data(wStream* s, const rdpMcs* mcs)
1931{
1932 WINPR_ASSERT(s);
1933 WINPR_ASSERT(mcs);
1934 if (mcs->channelCount > 0)
1935 {
1936 const size_t length = mcs->channelCount * 12 + 8;
1937 WINPR_ASSERT(length <= UINT16_MAX);
1938 if (!gcc_write_user_data_header(s, CS_NET, (UINT16)length))
1939 return FALSE;
1940 Stream_Write_UINT32(s, mcs->channelCount); /* channelCount */
1941
1942 /* channelDefArray */
1943 for (UINT32 i = 0; i < mcs->channelCount; i++)
1944 {
1945 /* CHANNEL_DEF */
1946 rdpMcsChannel* channel = &mcs->channels[i];
1947 Stream_Write(s, channel->Name, CHANNEL_NAME_LEN + 1); /* name (8 bytes) */
1948 Stream_Write_UINT32(s, channel->options); /* options (4 bytes) */
1949 }
1950 }
1951 return TRUE;
1952}
1953
1954BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs)
1955{
1956 UINT16 channelId = 0;
1957 UINT32 parsedChannelCount = 0;
1958 WINPR_ASSERT(s);
1959 WINPR_ASSERT(mcs);
1960 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1961 return FALSE;
1962
1963 mcs->IOChannelId = Stream_Get_UINT16(s); /* MCSChannelId */
1964 const uint16_t channelCount = Stream_Get_UINT16(s); /* channelCount */
1965 parsedChannelCount = channelCount;
1966
1967 if (channelCount != mcs->channelCount)
1968 {
1969 WLog_Print(mcs->log, WLOG_ERROR, "requested %" PRIu32 " channels, got %" PRIu16 " instead",
1970 mcs->channelCount, channelCount);
1971
1972 /* we ensure that the response is not bigger than the request */
1973
1974 mcs->channelCount = channelCount;
1975 }
1976
1977 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, channelCount, 2ull))
1978 return FALSE;
1979
1980 if (mcs->channelMaxCount < parsedChannelCount)
1981 {
1982 WLog_Print(mcs->log, WLOG_ERROR,
1983 "requested %" PRIu32 " channels > channelMaxCount %" PRIu16, mcs->channelCount,
1984 mcs->channelMaxCount);
1985 return FALSE;
1986 }
1987
1988 for (UINT32 i = 0; i < parsedChannelCount; i++)
1989 {
1990 rdpMcsChannel* channel = &mcs->channels[i];
1991 Stream_Read_UINT16(s, channelId); /* channelId */
1992 channel->ChannelId = channelId;
1993 }
1994
1995 if (channelCount % 2 == 1)
1996 return Stream_SafeSeek(s, 2); /* padding */
1997
1998 return TRUE;
1999}
2000
2001BOOL gcc_write_server_network_data(wStream* s, const rdpMcs* mcs)
2002{
2003 WINPR_ASSERT(s);
2004 WINPR_ASSERT(mcs);
2005 const size_t payloadLen =
2006 8ull + mcs->channelCount * 2ull + (mcs->channelCount % 2 == 1 ? 2ull : 0ull);
2007
2008 WINPR_ASSERT(payloadLen <= UINT16_MAX);
2009 if (!gcc_write_user_data_header(s, SC_NET, (UINT16)payloadLen))
2010 return FALSE;
2011
2012 Stream_Write_UINT16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
2013 Stream_Write_UINT16(s,
2014 WINPR_ASSERTING_INT_CAST(uint16_t, mcs->channelCount)); /* channelCount */
2015
2016 for (UINT32 i = 0; i < mcs->channelCount; i++)
2017 {
2018 const rdpMcsChannel* channel = &mcs->channels[i];
2019 Stream_Write_UINT16(s, channel->ChannelId);
2020 }
2021
2022 if (mcs->channelCount % 2 == 1)
2023 Stream_Write_UINT16(s, 0);
2024
2025 return TRUE;
2026}
2027
2037BOOL gcc_read_client_cluster_data(wStream* s, rdpMcs* mcs)
2038{
2039 char buffer[128] = WINPR_C_ARRAY_INIT;
2040 UINT32 redirectedSessionId = 0;
2041 rdpSettings* settings = mcs_get_settings(mcs);
2042
2043 WINPR_ASSERT(s);
2044 WINPR_ASSERT(settings);
2045
2046 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
2047 return FALSE;
2048
2049 Stream_Read_UINT32(s, settings->ClusterInfoFlags); /* flags */
2050 Stream_Read_UINT32(s, redirectedSessionId); /* redirectedSessionId */
2051
2052 WLog_Print(mcs->log, WLOG_TRACE, "read ClusterInfoFlags=%s, RedirectedSessionId=0x%08" PRIx32,
2053 rdp_cluster_info_flags_to_string(settings->ClusterInfoFlags, buffer, sizeof(buffer)),
2054 redirectedSessionId);
2055 if (settings->ClusterInfoFlags & REDIRECTED_SESSIONID_FIELD_VALID)
2056 settings->RedirectedSessionId = redirectedSessionId;
2057
2058 settings->ConsoleSession = (settings->ClusterInfoFlags & REDIRECTED_SESSIONID_FIELD_VALID) != 0;
2059 settings->RedirectSmartCards = (settings->ClusterInfoFlags & REDIRECTED_SMARTCARD) != 0;
2060
2061 if (Stream_GetRemainingLength(s) > 0)
2062 {
2063 /* The old Microsoft Mac RDP client can send a pad here */
2064 Stream_Seek(s, Stream_GetRemainingLength(s));
2065 }
2066
2067 return TRUE;
2068}
2069
2079BOOL gcc_write_client_cluster_data(wStream* s, const rdpMcs* mcs)
2080{
2081 char buffer[128] = WINPR_C_ARRAY_INIT;
2082 UINT32 flags = 0;
2083 const rdpSettings* settings = mcs_get_const_settings(mcs);
2084
2085 WINPR_ASSERT(s);
2086 WINPR_ASSERT(settings);
2087
2088 if (!gcc_write_user_data_header(s, CS_CLUSTER, 12))
2089 return FALSE;
2090 flags = settings->ClusterInfoFlags;
2091
2092 if (settings->ConsoleSession || settings->RedirectedSessionId)
2093 flags |= REDIRECTED_SESSIONID_FIELD_VALID;
2094
2095 if (settings->RedirectSmartCards && settings->SmartcardLogon)
2096 flags |= REDIRECTED_SMARTCARD;
2097
2098 if (flags & REDIRECTION_SUPPORTED)
2099 {
2100 /* REDIRECTION_VERSION6 requires multitransport enabled.
2101 * if we run without that use REDIRECTION_VERSION5 */
2102 if (freerdp_settings_get_bool(settings, FreeRDP_SupportMultitransport))
2103 flags |= (REDIRECTION_VERSION6 << 2);
2104 else
2105 flags |= (REDIRECTION_VERSION5 << 2);
2106 }
2107
2108 WLog_Print(mcs->log, WLOG_TRACE, "write ClusterInfoFlags=%s, RedirectedSessionId=0x%08" PRIx32,
2109 rdp_cluster_info_flags_to_string(flags, buffer, sizeof(buffer)),
2110 settings->RedirectedSessionId);
2111 Stream_Write_UINT32(s, flags); /* flags */
2112 Stream_Write_UINT32(s, settings->RedirectedSessionId); /* redirectedSessionID */
2113 return TRUE;
2114}
2115
2125BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs)
2126{
2127 UINT32 monitorCount = 0;
2128 rdpSettings* settings = mcs_get_settings(mcs);
2129
2130 WINPR_ASSERT(s);
2131 WINPR_ASSERT(settings);
2132
2133 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
2134 return FALSE;
2135
2136 Stream_Read_UINT32(s, settings->MonitorFlags); /* flags */
2137 Stream_Read_UINT32(s, monitorCount); /* monitorCount */
2138
2139 /* 2.2.1.3.6 Client Monitor Data -
2140 * monitorCount (4 bytes): A 32-bit, unsigned integer. The number of display
2141 * monitor definitions in the monitorDefArray field (the maximum allowed is 16).
2142 */
2143 if (monitorCount > 16)
2144 {
2145 WLog_Print(mcs->log, WLOG_ERROR, "announced monitors(%" PRIu32 ") exceed the 16 limit",
2146 monitorCount);
2147 return FALSE;
2148 }
2149
2150 if (monitorCount > settings->MonitorDefArraySize)
2151 {
2152 WLog_Print(mcs->log, WLOG_ERROR,
2153 "too many announced monitors(%" PRIu32 "), clamping to %" PRIu32 "",
2154 monitorCount, settings->MonitorDefArraySize);
2155 monitorCount = settings->MonitorDefArraySize;
2156 }
2157
2158 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, monitorCount, 20))
2159 return FALSE;
2160
2161 settings->MonitorCount = monitorCount;
2162
2163 for (UINT32 index = 0; index < monitorCount; index++)
2164 {
2165 rdpMonitor* current = &settings->MonitorDefArray[index];
2166
2167 const INT32 left = Stream_Get_INT32(s); /* left */
2168 const INT32 top = Stream_Get_INT32(s); /* top */
2169 const INT32 right = Stream_Get_INT32(s); /* right */
2170 const INT32 bottom = Stream_Get_INT32(s); /* bottom */
2171 const UINT32 flags = Stream_Get_UINT32(s); /* flags */
2172
2173 if ((1ll * left > right) || (1ll * top > bottom))
2174 {
2175 WLog_Print(mcs->log, WLOG_ERROR, "rdpMonitor::rect %dx%d-%dx%d invalid", left, top,
2176 right, bottom);
2177 return FALSE;
2178 }
2179
2180 const INT64 w = 1ll * right - left;
2181 const INT64 h = 1ll * bottom - top;
2182 if ((w >= INT32_MAX) || (h >= INT32_MAX) || (w < 0) || (h < 0))
2183 {
2184 WLog_Print(mcs->log, WLOG_ERROR,
2185 "rdpMonitor::width/height %" PRId64 "/%" PRId64 " invalid", w, h);
2186 return FALSE;
2187 }
2188
2189 current->x = left;
2190 current->y = top;
2191 current->width = WINPR_ASSERTING_INT_CAST(int32_t, w + 1);
2192 current->height = WINPR_ASSERTING_INT_CAST(int32_t, h + 1);
2193 current->is_primary = (flags & MONITOR_PRIMARY) != 0;
2194 }
2195
2196 return TRUE;
2197}
2198
2208BOOL gcc_write_client_monitor_data(wStream* s, const rdpMcs* mcs)
2209{
2210 INT32 baseX = 0;
2211 INT32 baseY = 0;
2212 const rdpSettings* settings = mcs_get_const_settings(mcs);
2213
2214 WINPR_ASSERT(s);
2215 WINPR_ASSERT(settings);
2216
2217 WLog_Print(mcs->log, WLOG_DEBUG, "MonitorCount=%" PRIu32, settings->MonitorCount);
2218 if (settings->MonitorCount > 1)
2219 {
2220 const size_t len = (20 * settings->MonitorCount) + 12;
2221 WINPR_ASSERT(len <= UINT16_MAX);
2222 const UINT16 length = (UINT16)len;
2223 if (!gcc_write_user_data_header(s, CS_MONITOR, length))
2224 return FALSE;
2225 Stream_Write_UINT32(s, settings->MonitorFlags); /* flags */
2226 Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
2227
2228 /* first pass to get the primary monitor coordinates (it is supposed to be
2229 * in (0,0) */
2230 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2231 {
2232 const rdpMonitor* current = &settings->MonitorDefArray[i];
2233 if (current->is_primary)
2234 {
2235 baseX = current->x;
2236 baseY = current->y;
2237 break;
2238 }
2239 }
2240
2241 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2242 {
2243 const rdpMonitor* current = &settings->MonitorDefArray[i];
2244 const INT32 left = current->x - baseX;
2245 const INT32 top = current->y - baseY;
2246 const INT32 right = left + current->width - 1;
2247 const INT32 bottom = top + current->height - 1;
2248 const UINT32 flags = current->is_primary ? MONITOR_PRIMARY : 0;
2249 WLog_Print(mcs->log, WLOG_DEBUG,
2250 "Monitor[%" PRIu32 "]: top=%" PRId32 ", left=%" PRId32 ", bottom=%" PRId32
2251 ", right=%" PRId32 ", flags=%" PRIu32,
2252 i, top, left, bottom, right, flags);
2253 Stream_Write_INT32(s, left); /* left */
2254 Stream_Write_INT32(s, top); /* top */
2255 Stream_Write_INT32(s, right); /* right */
2256 Stream_Write_INT32(s, bottom); /* bottom */
2257 Stream_Write_UINT32(s, flags); /* flags */
2258 }
2259 }
2260 WLog_Print(mcs->log, WLOG_DEBUG, "FINISHED");
2261 return TRUE;
2262}
2263
2264BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs)
2265{
2266 UINT32 monitorCount = 0;
2267 UINT32 monitorAttributeSize = 0;
2268 rdpSettings* settings = mcs_get_settings(mcs);
2269
2270 WINPR_ASSERT(s);
2271 WINPR_ASSERT(settings);
2272
2273 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 12))
2274 return FALSE;
2275
2276 Stream_Read_UINT32(s, settings->MonitorAttributeFlags); /* flags */
2277 Stream_Read_UINT32(s, monitorAttributeSize); /* monitorAttributeSize */
2278 Stream_Read_UINT32(s, monitorCount); /* monitorCount */
2279
2280 if (monitorAttributeSize != 20)
2281 {
2282 WLog_Print(mcs->log, WLOG_ERROR,
2283 "TS_UD_CS_MONITOR_EX::monitorAttributeSize %" PRIu32 " != 20",
2284 monitorAttributeSize);
2285 return FALSE;
2286 }
2287
2288 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, monitorCount,
2289 monitorAttributeSize))
2290 return FALSE;
2291
2292 if (settings->MonitorCount != monitorCount)
2293 {
2294 WLog_Print(mcs->log, WLOG_ERROR,
2295 "(TS_UD_CS_MONITOR_EX)::monitorCount %" PRIu32 " != expected %" PRIu32,
2296 monitorCount, settings->MonitorCount);
2297 return FALSE;
2298 }
2299
2300 settings->HasMonitorAttributes = TRUE;
2301
2302 for (UINT32 index = 0; index < monitorCount; index++)
2303 {
2304 rdpMonitor* current = &settings->MonitorDefArray[index];
2305 Stream_Read_UINT32(s, current->attributes.physicalWidth); /* physicalWidth */
2306 Stream_Read_UINT32(s, current->attributes.physicalHeight); /* physicalHeight */
2307 Stream_Read_UINT32(s, current->attributes.orientation); /* orientation */
2308 Stream_Read_UINT32(s, current->attributes.desktopScaleFactor); /* desktopScaleFactor */
2309 Stream_Read_UINT32(s, current->attributes.deviceScaleFactor); /* deviceScaleFactor */
2310 }
2311
2312 return TRUE;
2313}
2314
2315BOOL gcc_write_client_monitor_extended_data(wStream* s, const rdpMcs* mcs)
2316{
2317 const rdpSettings* settings = mcs_get_const_settings(mcs);
2318
2319 WINPR_ASSERT(s);
2320 WINPR_ASSERT(settings);
2321
2322 if (settings->HasMonitorAttributes)
2323 {
2324 const size_t length = (20 * settings->MonitorCount) + 16;
2325 WINPR_ASSERT(length <= UINT16_MAX);
2326 if (!gcc_write_user_data_header(s, CS_MONITOR_EX, (UINT16)length))
2327 return FALSE;
2328 Stream_Write_UINT32(s, settings->MonitorAttributeFlags); /* flags */
2329 Stream_Write_UINT32(s, 20); /* monitorAttributeSize */
2330 Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
2331
2332 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2333 {
2334 const rdpMonitor* current = &settings->MonitorDefArray[i];
2335 Stream_Write_UINT32(s, current->attributes.physicalWidth); /* physicalWidth */
2336 Stream_Write_UINT32(s, current->attributes.physicalHeight); /* physicalHeight */
2337 Stream_Write_UINT32(s, current->attributes.orientation); /* orientation */
2338 Stream_Write_UINT32(s, current->attributes.desktopScaleFactor); /* desktopScaleFactor */
2339 Stream_Write_UINT32(s, current->attributes.deviceScaleFactor); /* deviceScaleFactor */
2340 }
2341 }
2342 return TRUE;
2343}
2344
2354BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs)
2355{
2356 WINPR_ASSERT(s);
2357 WINPR_ASSERT(mcs);
2358
2359 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2360 return FALSE;
2361
2362 Stream_Read_UINT32(s, mcs->flags);
2363 mcs->messageChannelId = mcs->baseChannelId++;
2364 return TRUE;
2365}
2366
2376BOOL gcc_write_client_message_channel_data(wStream* s, const rdpMcs* mcs)
2377{
2378 const rdpSettings* settings = mcs_get_const_settings(mcs);
2379
2380 WINPR_ASSERT(s);
2381 WINPR_ASSERT(mcs);
2382 WINPR_ASSERT(settings);
2383 if (freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect) ||
2384 settings->SupportHeartbeatPdu || settings->SupportMultitransport)
2385 {
2386 if (!gcc_write_user_data_header(s, CS_MCS_MSGCHANNEL, 8))
2387 return FALSE;
2388 Stream_Write_UINT32(s, mcs->flags); /* flags */
2389 }
2390 return TRUE;
2391}
2392
2393BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs)
2394{
2395 UINT16 MCSChannelId = 0;
2396 WINPR_ASSERT(s);
2397 WINPR_ASSERT(mcs);
2398 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
2399 return FALSE;
2400
2401 Stream_Read_UINT16(s, MCSChannelId); /* MCSChannelId */
2402 /* Save the MCS message channel id */
2403 mcs->messageChannelId = MCSChannelId;
2404 return TRUE;
2405}
2406
2407BOOL gcc_write_server_message_channel_data(wStream* s, const rdpMcs* mcs)
2408{
2409 WINPR_ASSERT(s);
2410 WINPR_ASSERT(mcs);
2411 if (mcs->messageChannelId == 0)
2412 return TRUE;
2413
2414 if (!gcc_write_user_data_header(s, SC_MCS_MSGCHANNEL, 6))
2415 return FALSE;
2416
2417 Stream_Write_UINT16(s, mcs->messageChannelId); /* mcsChannelId (2 bytes) */
2418 return TRUE;
2419}
2420
2430BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs)
2431{
2432 rdpSettings* settings = mcs_get_settings(mcs);
2433
2434 WINPR_ASSERT(s);
2435 WINPR_ASSERT(settings);
2436
2437 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2438 return FALSE;
2439
2440 UINT32 remoteFlags = 0;
2441 Stream_Read_UINT32(s, remoteFlags);
2442 settings->MultitransportFlags &= remoteFlags; /* merge local and remote flags */
2443 return TRUE;
2444}
2445
2456BOOL gcc_write_client_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
2457{
2458 const rdpSettings* settings = mcs_get_const_settings(mcs);
2459
2460 WINPR_ASSERT(s);
2461 WINPR_ASSERT(settings);
2462 if (!gcc_write_user_data_header(s, CS_MULTITRANSPORT, 8))
2463 return FALSE;
2464 Stream_Write_UINT32(s, settings->MultitransportFlags); /* flags */
2465 return TRUE;
2466}
2467
2468BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs)
2469{
2470 rdpSettings* settings = mcs_get_settings(mcs);
2471 UINT32 remoteFlags = 0;
2472
2473 WINPR_ASSERT(s);
2474 WINPR_ASSERT(settings);
2475 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2476 return FALSE;
2477
2478 Stream_Read_UINT32(s, remoteFlags);
2479 settings->MultitransportFlags &= remoteFlags; /* merge with client setting */
2480 return TRUE;
2481}
2482
2483BOOL gcc_write_server_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
2484{
2485 const rdpSettings* settings = mcs_get_const_settings(mcs);
2486
2487 WINPR_ASSERT(s);
2488 WINPR_ASSERT(settings);
2489
2490 if (!gcc_write_user_data_header(s, SC_MULTITRANSPORT, 8))
2491 return FALSE;
2492
2493 Stream_Write_UINT32(s, settings->MultitransportFlags); /* flags (4 bytes) */
2494 return TRUE;
2495}
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_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
Sets a BOOL settings value.
freerdp_settings_get_pointer_writable
WINPR_ATTR_NODISCARD FREERDP_API void * freerdp_settings_get_pointer_writable(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a mutable pointer settings value.
Definition settings_getters.c:4174
freerdp_settings_get_uint16
WINPR_ATTR_NODISCARD FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id)
Returns a UINT16 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_set_pointer_len
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_pointer_len(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data, size_t len)
Set a pointer to value data.
Definition common/settings.c:1432
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_set_string
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *val)
Sets a string settings value. The param is copied.
Definition settings_getters.c:3803
freerdp_supported_color_depths_string
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_supported_color_depths_string(UINT16 mask, char *buffer, size_t size)
returns a string representation of RNS_UD_XXBPP_SUPPORT values
Definition common/settings.c:2372
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.
rdpMonitor
Definition settings_types.h:446