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, 4 + 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 UINT32 version = 0;
1169 BYTE connectionType = 0;
1170 UINT32 clientColorDepth = 0;
1171 UINT16 colorDepth = 0;
1172 UINT16 postBeta2ColorDepth = 0;
1173 UINT16 highColorDepth = 0;
1174 UINT32 serverSelectedProtocol = 0;
1175 rdpSettings* settings = mcs_get_settings(mcs);
1176
1177 WINPR_ASSERT(s);
1178 WINPR_ASSERT(settings);
1179
1180 /* Length of all required fields, until imeFileName */
1181 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 128))
1182 return FALSE;
1183
1184 Stream_Read_UINT32(s, version); /* version (4 bytes) */
1185 settings->RdpVersion = rdp_version_common(mcs->log, version, settings->RdpVersion);
1186 Stream_Read_UINT16(s, settings->DesktopWidth); /* DesktopWidth (2 bytes) */
1187 Stream_Read_UINT16(s, settings->DesktopHeight); /* DesktopHeight (2 bytes) */
1188 Stream_Read_UINT16(s, colorDepth); /* ColorDepth (2 bytes) */
1189 Stream_Seek_UINT16(s); /* SASSequence (Secure Access Sequence) (2 bytes) */
1190 Stream_Read_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout (4 bytes) */
1191 Stream_Read_UINT32(s, settings->ClientBuild); /* ClientBuild (4 bytes) */
1192
1193 /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
1194 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, 32 / sizeof(WCHAR), strbuffer,
1195 ARRAYSIZE(strbuffer)) < 0)
1196 {
1197 WLog_Print(mcs->log, WLOG_ERROR, "failed to convert client host name");
1198 return FALSE;
1199 }
1200
1201 if (!freerdp_settings_set_string(settings, FreeRDP_ClientHostname, strbuffer))
1202 return FALSE;
1203
1204 Stream_Read_UINT32(s, settings->KeyboardType); /* KeyboardType (4 bytes) */
1205 Stream_Read_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType (4 bytes) */
1206 Stream_Read_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey (4 bytes) */
1207 Stream_Seek(s, 64); /* imeFileName (64 bytes) */
1208
1216 do
1217 {
1218 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1219 break;
1220
1221 Stream_Read_UINT16(s, postBeta2ColorDepth); /* postBeta2ColorDepth (2 bytes) */
1222
1223 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1224 break;
1225
1226 const UINT16 clientProductId = Stream_Get_UINT16(s); /* clientProductID (2 bytes) */
1227
1228 /* [MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::clientProductId (optional)
1229 * should be initialized to 1
1230 */
1231 if (clientProductId != 1)
1232 {
1233 WLog_Print(mcs->log, WLOG_WARN,
1234 "[MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::clientProductId "
1235 "(optional) expected 1, got %" PRIu32,
1236 clientProductId);
1237 }
1238
1239 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1240 break;
1241
1242 const UINT32 serialNumber = Stream_Get_UINT32(s); /* serialNumber (4 bytes) */
1243
1244 /* [MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::serialNumber (optional)
1245 * should be initialized to 0
1246 */
1247 if (serialNumber != 0)
1248 {
1249 WLog_Print(mcs->log, WLOG_WARN,
1250 "[MS-RDPBCGR] 2.2.1.3.2 Client Core Data (TS_UD_CS_CORE)::serialNumber "
1251 "(optional) expected 0, got %" PRIu32,
1252 serialNumber);
1253 }
1254
1255 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1256 break;
1257
1258 Stream_Read_UINT16(s, highColorDepth); /* highColorDepth (2 bytes) */
1259
1260 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1261 break;
1262
1263 Stream_Read_UINT16(s, settings->SupportedColorDepths); /* supportedColorDepths (2 bytes) */
1264
1265 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1266 break;
1267
1268 Stream_Read_UINT16(s, settings->EarlyCapabilityFlags); /* earlyCapabilityFlags (2 bytes) */
1269
1270 /* clientDigProductId (64 bytes): Contains a value that uniquely identifies the client */
1271 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 64))
1272 break;
1273
1274 if (Stream_Read_UTF16_String_As_UTF8_Buffer(s, 64 / sizeof(WCHAR), strbuffer,
1275 ARRAYSIZE(strbuffer)) < 0)
1276 {
1277 WLog_Print(mcs->log, WLOG_ERROR, "failed to convert the client product identifier");
1278 return FALSE;
1279 }
1280
1281 if (!freerdp_settings_set_string(settings, FreeRDP_ClientProductId, strbuffer))
1282 return FALSE;
1283
1284 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 1))
1285 break;
1286
1287 Stream_Read_UINT8(s, connectionType); /* connectionType (1 byte) */
1288
1289 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 1))
1290 break;
1291
1292 Stream_Seek_UINT8(s); /* pad1octet (1 byte) */
1293
1294 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1295 break;
1296
1297 Stream_Read_UINT32(s, serverSelectedProtocol); /* serverSelectedProtocol (4 bytes) */
1298
1299 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1300 break;
1301
1302 Stream_Read_UINT32(s, settings->DesktopPhysicalWidth); /* desktopPhysicalWidth (4 bytes) */
1303
1304 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1305 break;
1306
1307 Stream_Read_UINT32(s,
1308 settings->DesktopPhysicalHeight); /* desktopPhysicalHeight (4 bytes) */
1309
1310 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
1311 break;
1312
1313 Stream_Read_UINT16(s, settings->DesktopOrientation); /* desktopOrientation (2 bytes) */
1314
1315 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1316 break;
1317
1318 Stream_Read_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor (4 bytes) */
1319
1320 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1321 break;
1322
1323 Stream_Read_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor (4 bytes) */
1324
1325 if (freerdp_settings_get_bool(settings, FreeRDP_TransportDumpReplay))
1326 settings->SelectedProtocol = serverSelectedProtocol;
1327 else if (settings->SelectedProtocol != serverSelectedProtocol)
1328 return FALSE;
1329 } while (0);
1330
1331 if (highColorDepth > 0)
1332 {
1333 if (settings->EarlyCapabilityFlags & RNS_UD_CS_WANT_32BPP_SESSION)
1334 clientColorDepth = 32;
1335 else
1336 clientColorDepth = highColorDepth;
1337 }
1338 else if (postBeta2ColorDepth > 0)
1339 {
1340 switch (postBeta2ColorDepth)
1341 {
1342 case RNS_UD_COLOR_4BPP:
1343 clientColorDepth = 4;
1344 break;
1345
1346 case RNS_UD_COLOR_8BPP:
1347 clientColorDepth = 8;
1348 break;
1349
1350 case RNS_UD_COLOR_16BPP_555:
1351 clientColorDepth = 15;
1352 break;
1353
1354 case RNS_UD_COLOR_16BPP_565:
1355 clientColorDepth = 16;
1356 break;
1357
1358 case RNS_UD_COLOR_24BPP:
1359 clientColorDepth = 24;
1360 break;
1361
1362 default:
1363 return FALSE;
1364 }
1365 }
1366 else
1367 {
1368 switch (colorDepth)
1369 {
1370 case RNS_UD_COLOR_4BPP:
1371 clientColorDepth = 4;
1372 break;
1373
1374 case RNS_UD_COLOR_8BPP:
1375 clientColorDepth = 8;
1376 break;
1377
1378 default:
1379 return FALSE;
1380 }
1381 }
1382
1383 /*
1384 * If we are in server mode, accept client's color depth only if
1385 * it is smaller than ours. This is what Windows server does.
1386 */
1387 if ((clientColorDepth < freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)) ||
1388 !settings->ServerMode)
1389 {
1390 if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, clientColorDepth))
1391 return FALSE;
1392 }
1393
1394 WLog_Print(
1395 mcs->log, WLOG_DEBUG, "Received EarlyCapabilityFlags=%s",
1396 rdp_early_client_caps_string(settings->EarlyCapabilityFlags, buffer, sizeof(buffer)));
1397
1398 return updateEarlyClientCaps(mcs->log, settings, settings->EarlyCapabilityFlags,
1399 connectionType);
1400}
1401
1411BOOL gcc_write_client_core_data(wStream* s, const rdpMcs* mcs)
1412{
1413 char buffer[2048] = WINPR_C_ARRAY_INIT;
1414 char dbuffer[2048] = WINPR_C_ARRAY_INIT;
1415 BYTE connectionType = 0;
1416 HIGH_COLOR_DEPTH highColorDepth = HIGH_COLOR_4BPP;
1417
1418 UINT16 earlyCapabilityFlags = 0;
1419 const rdpSettings* settings = mcs_get_const_settings(mcs);
1420
1421 WINPR_ASSERT(s);
1422 WINPR_ASSERT(settings);
1423
1424 const UINT16 SupportedColorDepths =
1425 freerdp_settings_get_uint16(settings, FreeRDP_SupportedColorDepths);
1426 const UINT32 ColorDepth = freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
1427
1428 if (!gcc_write_user_data_header(s, CS_CORE, 234))
1429 return FALSE;
1430
1431 Stream_Write_UINT32(s, settings->RdpVersion); /* Version */
1432 Stream_Write_UINT16(
1433 s, WINPR_ASSERTING_INT_CAST(uint16_t, settings->DesktopWidth)); /* DesktopWidth */
1434 Stream_Write_UINT16(
1435 s, WINPR_ASSERTING_INT_CAST(uint16_t, settings->DesktopHeight)); /* DesktopHeight */
1436 Stream_Write_UINT16(s,
1437 RNS_UD_COLOR_8BPP); /* ColorDepth, ignored because of postBeta2ColorDepth */
1438 Stream_Write_UINT16(s, RNS_UD_SAS_DEL); /* SASSequence (Secure Access Sequence) */
1439 Stream_Write_UINT32(s, settings->KeyboardLayout); /* KeyboardLayout */
1440 Stream_Write_UINT32(s, settings->ClientBuild); /* ClientBuild */
1441
1442 if (!Stream_EnsureRemainingCapacity(s, 32 + 12 + 64 + 8))
1443 return FALSE;
1444
1445 /* clientName (32 bytes, null-terminated unicode, truncated to 15 characters) */
1446 size_t clientNameLength = 0;
1447 WCHAR* clientName = ConvertUtf8ToWCharAlloc(settings->ClientHostname, &clientNameLength);
1448 if (clientNameLength >= 16)
1449 {
1450 clientNameLength = 16;
1451 clientName[clientNameLength - 1] = 0;
1452 }
1453
1454 Stream_Write(s, clientName, (clientNameLength * 2));
1455 Stream_Zero(s, 32 - (clientNameLength * 2));
1456 free(clientName);
1457 Stream_Write_UINT32(s, settings->KeyboardType); /* KeyboardType */
1458 Stream_Write_UINT32(s, settings->KeyboardSubType); /* KeyboardSubType */
1459 Stream_Write_UINT32(s, settings->KeyboardFunctionKey); /* KeyboardFunctionKey */
1460 Stream_Zero(s, 64); /* imeFileName */
1461 Stream_Write_UINT16(s, RNS_UD_COLOR_8BPP); /* postBeta2ColorDepth */
1462 Stream_Write_UINT16(s, 1); /* clientProductID */
1463 Stream_Write_UINT32(s, 0); /* serialNumber (should be initialized to 0) */
1464 highColorDepth = ColorDepthToHighColor(ColorDepth);
1465 earlyCapabilityFlags = earlyClientCapsFromSettings(mcs->log, settings);
1466
1467 WINPR_ASSERT(settings->ConnectionType <= UINT8_MAX);
1468 connectionType = (UINT8)settings->ConnectionType;
1469
1470 if (!Stream_EnsureRemainingCapacity(s, 6))
1471 return FALSE;
1472
1473 WLog_Print(
1474 mcs->log, WLOG_DEBUG,
1475 "Sending highColorDepth=%s, supportedColorDepths=%s, earlyCapabilityFlags=%s",
1476 HighColorToString(highColorDepth),
1477 freerdp_supported_color_depths_string(SupportedColorDepths, dbuffer, sizeof(dbuffer)),
1478 rdp_early_client_caps_string(earlyCapabilityFlags, buffer, sizeof(buffer)));
1479 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, highColorDepth)); /* highColorDepth */
1480 Stream_Write_UINT16(s, SupportedColorDepths); /* supportedColorDepths */
1481 Stream_Write_UINT16(s, earlyCapabilityFlags); /* earlyCapabilityFlags */
1482
1483 if (!Stream_EnsureRemainingCapacity(s, 64 + 24))
1484 return FALSE;
1485
1486 /* clientDigProductId (64 bytes, assume WCHAR, not \0 terminated */
1487 const char* str = freerdp_settings_get_string(settings, FreeRDP_ClientProductId);
1488 if (str)
1489 {
1490 if (Stream_Write_UTF16_String_From_UTF8(s, 32, str, strnlen(str, 32), TRUE) < 0)
1491 return FALSE;
1492 }
1493 else
1494 Stream_Zero(s, 32 * sizeof(WCHAR));
1495
1496 Stream_Write_UINT8(s, connectionType); /* connectionType */
1497 Stream_Write_UINT8(s, 0); /* pad1octet */
1498 Stream_Write_UINT32(s, settings->SelectedProtocol); /* serverSelectedProtocol */
1499 Stream_Write_UINT32(s, settings->DesktopPhysicalWidth); /* desktopPhysicalWidth */
1500 Stream_Write_UINT32(s, settings->DesktopPhysicalHeight); /* desktopPhysicalHeight */
1501 Stream_Write_UINT16(s, settings->DesktopOrientation); /* desktopOrientation */
1502 Stream_Write_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor */
1503 Stream_Write_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor */
1504 return TRUE;
1505}
1506
1507BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs)
1508{
1509 UINT32 serverVersion = 0;
1510 rdpSettings* settings = mcs_get_settings(mcs);
1511
1512 WINPR_ASSERT(s);
1513 WINPR_ASSERT(settings);
1514
1515 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1516 return FALSE;
1517
1518 Stream_Read_UINT32(s, serverVersion); /* version */
1519 settings->RdpVersion = rdp_version_common(mcs->log, serverVersion, settings->RdpVersion);
1520
1521 if (Stream_GetRemainingLength(s) >= 4)
1522 {
1523 Stream_Read_UINT32(s, settings->RequestedProtocols); /* clientRequestedProtocols */
1524 }
1525
1526 if (Stream_GetRemainingLength(s) >= 4)
1527 {
1528 char buffer[2048] = WINPR_C_ARRAY_INIT;
1529
1530 Stream_Read_UINT32(s, settings->EarlyCapabilityFlags); /* earlyCapabilityFlags */
1531 WLog_Print(
1532 mcs->log, WLOG_DEBUG, "Received EarlyCapabilityFlags=%s",
1533 rdp_early_client_caps_string(settings->EarlyCapabilityFlags, buffer, sizeof(buffer)));
1534 }
1535
1536 return updateEarlyServerCaps(mcs->log, settings, settings->EarlyCapabilityFlags,
1537 settings->ConnectionType);
1538}
1539
1540/* TODO: This function modifies rdpMcs
1541 * TODO: Split this out of this function
1542 */
1543BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs)
1544{
1545 const rdpSettings* settings = mcs_get_const_settings(mcs);
1546
1547 WINPR_ASSERT(s);
1548 WINPR_ASSERT(settings);
1549
1550 if (!gcc_write_user_data_header(s, SC_CORE, 16))
1551 return FALSE;
1552
1553 const UINT32 EarlyCapabilityFlags = earlyServerCapsFromSettings(mcs->log, settings);
1554 Stream_Write_UINT32(s, settings->RdpVersion); /* version (4 bytes) */
1555 Stream_Write_UINT32(s, settings->RequestedProtocols); /* clientRequestedProtocols (4 bytes) */
1556 Stream_Write_UINT32(s, EarlyCapabilityFlags); /* earlyCapabilityFlags (4 bytes) */
1557 return TRUE;
1558}
1559
1569BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs)
1570{
1571 rdpSettings* settings = mcs_get_settings(mcs);
1572
1573 WINPR_ASSERT(s);
1574 WINPR_ASSERT(settings);
1575
1576 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1577 return FALSE;
1578
1579 if (settings->UseRdpSecurityLayer)
1580 {
1581 Stream_Read_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
1582
1583 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1584 Stream_Read_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
1585 else
1586 Stream_Seek(s, 4);
1587 }
1588 else
1589 {
1590 Stream_Seek(s, 8);
1591 }
1592
1593 return TRUE;
1594}
1595
1605BOOL gcc_write_client_security_data(wStream* s, const rdpMcs* mcs)
1606{
1607 const rdpSettings* settings = mcs_get_const_settings(mcs);
1608
1609 WINPR_ASSERT(s);
1610 WINPR_ASSERT(settings);
1611
1612 if (!gcc_write_user_data_header(s, CS_SECURITY, 12))
1613 return FALSE;
1614
1615 if (settings->UseRdpSecurityLayer)
1616 {
1617 Stream_Write_UINT32(s, settings->EncryptionMethods); /* encryptionMethods */
1618 Stream_Write_UINT32(s, 0); /* extEncryptionMethods */
1619 }
1620 else
1621 {
1622 /* French locale, disable encryption */
1623 Stream_Write_UINT32(s, 0); /* encryptionMethods */
1624 Stream_Write_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
1625 }
1626 return TRUE;
1627}
1628
1629BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs)
1630{
1631 BOOL validCryptoConfig = FALSE;
1632 UINT32 EncryptionMethod = 0;
1633 UINT32 EncryptionLevel = 0;
1634 rdpSettings* settings = mcs_get_settings(mcs);
1635
1636 WINPR_ASSERT(s);
1637 WINPR_ASSERT(settings);
1638
1639 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1640 return FALSE;
1641
1642 Stream_Read_UINT32(s, EncryptionMethod); /* encryptionMethod */
1643 Stream_Read_UINT32(s, EncryptionLevel); /* encryptionLevel */
1644
1645 /* Only accept valid/known encryption methods */
1646 switch (EncryptionMethod)
1647 {
1648 case ENCRYPTION_METHOD_NONE:
1649 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: NONE");
1650 break;
1651
1652 case ENCRYPTION_METHOD_40BIT:
1653 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 40BIT");
1654 break;
1655
1656 case ENCRYPTION_METHOD_56BIT:
1657 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 56BIT");
1658 break;
1659
1660 case ENCRYPTION_METHOD_128BIT:
1661 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: 128BIT");
1662 break;
1663
1664 case ENCRYPTION_METHOD_FIPS:
1665 WLog_Print(mcs->log, WLOG_DEBUG, "Server rdp encryption method: FIPS");
1666 break;
1667
1668 default:
1669 WLog_Print(mcs->log, WLOG_ERROR, "Received unknown encryption method %08" PRIX32 "",
1670 EncryptionMethod);
1671 return FALSE;
1672 }
1673
1674 if (settings->UseRdpSecurityLayer && !(settings->EncryptionMethods & EncryptionMethod))
1675 {
1676 WLog_Print(mcs->log, WLOG_WARN,
1677 "Server uses non-advertised encryption method 0x%08" PRIX32 "",
1678 EncryptionMethod);
1679 /* FIXME: Should we return FALSE; in this case ?? */
1680 }
1681
1682 settings->EncryptionMethods = EncryptionMethod;
1683 settings->EncryptionLevel = EncryptionLevel;
1684 /* Verify encryption level/method combinations according to MS-RDPBCGR Section 5.3.2 */
1685 switch (settings->EncryptionLevel)
1686 {
1687 case ENCRYPTION_LEVEL_NONE:
1688 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1689 {
1690 validCryptoConfig = TRUE;
1691 }
1692
1693 break;
1694
1695 case ENCRYPTION_LEVEL_FIPS:
1696 if (settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1697 {
1698 validCryptoConfig = TRUE;
1699 }
1700
1701 break;
1702
1703 case ENCRYPTION_LEVEL_LOW:
1704 case ENCRYPTION_LEVEL_HIGH:
1705 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
1706 if (settings->EncryptionMethods == ENCRYPTION_METHOD_40BIT ||
1707 settings->EncryptionMethods == ENCRYPTION_METHOD_56BIT ||
1708 settings->EncryptionMethods == ENCRYPTION_METHOD_128BIT ||
1709 settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1710 {
1711 validCryptoConfig = TRUE;
1712 }
1713
1714 break;
1715
1716 default:
1717 WLog_Print(mcs->log, WLOG_ERROR, "Received unknown encryption level 0x%08" PRIX32 "",
1718 settings->EncryptionLevel);
1719 }
1720
1721 if (!validCryptoConfig)
1722 {
1723 WLog_Print(mcs->log, WLOG_ERROR,
1724 "Received invalid cryptographic configuration (level=0x%08" PRIX32
1725 " method=0x%08" PRIX32 ")",
1726 settings->EncryptionLevel, settings->EncryptionMethods);
1727 return FALSE;
1728 }
1729
1730 if (settings->EncryptionLevel == ENCRYPTION_LEVEL_NONE)
1731 {
1732 /* serverRandomLen and serverCertLen must not be present */
1733 settings->UseRdpSecurityLayer = FALSE;
1734 return TRUE;
1735 }
1736
1737 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
1738 return FALSE;
1739
1740 Stream_Read_UINT32(s, settings->ServerRandomLength); /* serverRandomLen */
1741 Stream_Read_UINT32(s, settings->ServerCertificateLength); /* serverCertLen */
1742
1743 if ((settings->ServerRandomLength == 0) || (settings->ServerCertificateLength == 0))
1744 {
1745 WLog_Print(mcs->log, WLOG_ERROR,
1746 "Invalid ServerRandom (length=%" PRIu32 ") or ServerCertificate (length=%" PRIu32
1747 ")",
1748 settings->ServerRandomLength, settings->ServerCertificateLength);
1749 return FALSE;
1750 }
1751
1752 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, settings->ServerRandomLength))
1753 return FALSE;
1754
1755 /* serverRandom */
1756 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr,
1757 settings->ServerRandomLength))
1758 goto fail;
1759
1760 Stream_Read(s, settings->ServerRandom, settings->ServerRandomLength);
1761
1762 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, settings->ServerCertificateLength))
1763 goto fail;
1764
1765 /* serverCertificate */
1766 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr,
1767 settings->ServerCertificateLength))
1768 goto fail;
1769
1770 Stream_Read(s, settings->ServerCertificate, settings->ServerCertificateLength);
1771
1772 {
1773 const BYTE* data = settings->ServerCertificate;
1774 const uint32_t length = settings->ServerCertificateLength;
1775
1776 if (!freerdp_certificate_read_server_cert(settings->RdpServerCertificate, data, length))
1777 goto fail;
1778 }
1779 return TRUE;
1780fail:
1781 freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, 0);
1782 freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, nullptr, 0);
1783 return FALSE;
1784}
1785
1786static BOOL gcc_update_server_random(rdpSettings* settings)
1787{
1788 const size_t length = 32;
1789 WINPR_ASSERT(settings);
1790 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, nullptr, length))
1791 return FALSE;
1792 BYTE* data = freerdp_settings_get_pointer_writable(settings, FreeRDP_ServerRandom);
1793 if (!data)
1794 return FALSE;
1795 return winpr_RAND(data, length) >= 0;
1796}
1797
1798/* TODO: This function does manipulate data in rdpMcs
1799 * TODO: Split this out of this function
1800 */
1801BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs)
1802{
1803 if (!gcc_update_server_random(mcs_get_settings(mcs)))
1804 return FALSE;
1805
1806 const rdpSettings* settings = mcs_get_const_settings(mcs);
1807
1808 WINPR_ASSERT(s);
1809 WINPR_ASSERT(settings);
1810
1811 const size_t posHeader = Stream_GetPosition(s);
1812 if (!gcc_write_user_data_header(s, SC_SECURITY, 12))
1813 return FALSE;
1814
1815 Stream_Write_UINT32(s, settings->EncryptionMethods); /* encryptionMethod */
1816 Stream_Write_UINT32(s, settings->EncryptionLevel); /* encryptionLevel */
1817
1818 if (settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1819 return TRUE;
1820
1821 if (!Stream_EnsureRemainingCapacity(s, sizeof(UINT32) + settings->ServerRandomLength))
1822 return FALSE;
1823 Stream_Write_UINT32(s, settings->ServerRandomLength); /* serverRandomLen */
1824 const size_t posCertLen = Stream_GetPosition(s);
1825 Stream_Seek_UINT32(s); /* serverCertLen */
1826 Stream_Write(s, settings->ServerRandom, settings->ServerRandomLength);
1827
1828 const SSIZE_T len = freerdp_certificate_write_server_cert(
1829 settings->RdpServerCertificate, CERT_TEMPORARILY_ISSUED | CERT_CHAIN_VERSION_1, s);
1830 if (len < 0)
1831 return FALSE;
1832 const size_t end = Stream_GetPosition(s);
1833
1834 WINPR_ASSERT(end >= posHeader);
1835 const size_t diff = end - posHeader;
1836 WINPR_ASSERT(diff <= UINT16_MAX);
1837 if (!Stream_SetPosition(s, posHeader))
1838 return FALSE;
1839 if (!gcc_write_user_data_header(s, SC_SECURITY, (UINT16)diff))
1840 return FALSE;
1841 if (!Stream_SetPosition(s, posCertLen))
1842 return FALSE;
1843 WINPR_ASSERT(len <= UINT32_MAX);
1844 Stream_Write_UINT32(s, (UINT32)len);
1845 return Stream_SetPosition(s, end);
1846}
1847
1858BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs)
1859{
1860 WINPR_ASSERT(s);
1861 WINPR_ASSERT(mcs);
1862
1863 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1864 return FALSE;
1865
1866 Stream_Read_UINT32(s, mcs->channelCount); /* channelCount */
1867
1868 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, mcs->channelCount, 12ull))
1869 return FALSE;
1870
1871 if (mcs->channelCount > CHANNEL_MAX_COUNT)
1872 {
1873 WLog_Print(mcs->log, WLOG_ERROR, "rdpMcs::channelCount %" PRIu32 " > maximum %d",
1874 mcs->channelCount, CHANNEL_MAX_COUNT);
1875 return FALSE;
1876 }
1877
1878 /* channelDefArray */
1879 for (UINT32 i = 0; i < mcs->channelCount; i++)
1880 {
1887 rdpMcsChannel* channel = &mcs->channels[i];
1888 Stream_Read(s, channel->Name, CHANNEL_NAME_LEN + 1); /* name (8 bytes) */
1889
1890 if (!memchr(channel->Name, 0, CHANNEL_NAME_LEN + 1))
1891 {
1892 WLog_Print(
1893 mcs->log, WLOG_ERROR,
1894 "protocol violation: received a static channel name with missing null-termination");
1895 return FALSE;
1896 }
1897
1898 Stream_Read_UINT32(s, channel->options); /* options (4 bytes) */
1899 channel->ChannelId = mcs->baseChannelId++;
1900 }
1901
1902 return TRUE;
1903}
1904
1914BOOL gcc_write_client_network_data(wStream* s, const rdpMcs* mcs)
1915{
1916 WINPR_ASSERT(s);
1917 WINPR_ASSERT(mcs);
1918 if (mcs->channelCount > 0)
1919 {
1920 const size_t length = mcs->channelCount * 12 + 8;
1921 WINPR_ASSERT(length <= UINT16_MAX);
1922 if (!gcc_write_user_data_header(s, CS_NET, (UINT16)length))
1923 return FALSE;
1924 Stream_Write_UINT32(s, mcs->channelCount); /* channelCount */
1925
1926 /* channelDefArray */
1927 for (UINT32 i = 0; i < mcs->channelCount; i++)
1928 {
1929 /* CHANNEL_DEF */
1930 rdpMcsChannel* channel = &mcs->channels[i];
1931 Stream_Write(s, channel->Name, CHANNEL_NAME_LEN + 1); /* name (8 bytes) */
1932 Stream_Write_UINT32(s, channel->options); /* options (4 bytes) */
1933 }
1934 }
1935 return TRUE;
1936}
1937
1938BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs)
1939{
1940 UINT16 channelId = 0;
1941 UINT32 parsedChannelCount = 0;
1942 WINPR_ASSERT(s);
1943 WINPR_ASSERT(mcs);
1944 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
1945 return FALSE;
1946
1947 mcs->IOChannelId = Stream_Get_UINT16(s); /* MCSChannelId */
1948 const uint16_t channelCount = Stream_Get_UINT16(s); /* channelCount */
1949 parsedChannelCount = channelCount;
1950
1951 if (channelCount != mcs->channelCount)
1952 {
1953 WLog_Print(mcs->log, WLOG_ERROR, "requested %" PRIu32 " channels, got %" PRIu16 " instead",
1954 mcs->channelCount, channelCount);
1955
1956 /* we ensure that the response is not bigger than the request */
1957
1958 mcs->channelCount = channelCount;
1959 }
1960
1961 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, channelCount, 2ull))
1962 return FALSE;
1963
1964 if (mcs->channelMaxCount < parsedChannelCount)
1965 {
1966 WLog_Print(mcs->log, WLOG_ERROR,
1967 "requested %" PRIu32 " channels > channelMaxCount %" PRIu16, mcs->channelCount,
1968 mcs->channelMaxCount);
1969 return FALSE;
1970 }
1971
1972 for (UINT32 i = 0; i < parsedChannelCount; i++)
1973 {
1974 rdpMcsChannel* channel = &mcs->channels[i];
1975 Stream_Read_UINT16(s, channelId); /* channelId */
1976 channel->ChannelId = channelId;
1977 }
1978
1979 if (channelCount % 2 == 1)
1980 return Stream_SafeSeek(s, 2); /* padding */
1981
1982 return TRUE;
1983}
1984
1985BOOL gcc_write_server_network_data(wStream* s, const rdpMcs* mcs)
1986{
1987 WINPR_ASSERT(s);
1988 WINPR_ASSERT(mcs);
1989 const size_t payloadLen =
1990 8ull + mcs->channelCount * 2ull + (mcs->channelCount % 2 == 1 ? 2ull : 0ull);
1991
1992 WINPR_ASSERT(payloadLen <= UINT16_MAX);
1993 if (!gcc_write_user_data_header(s, SC_NET, (UINT16)payloadLen))
1994 return FALSE;
1995
1996 Stream_Write_UINT16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
1997 Stream_Write_UINT16(s,
1998 WINPR_ASSERTING_INT_CAST(uint16_t, mcs->channelCount)); /* channelCount */
1999
2000 for (UINT32 i = 0; i < mcs->channelCount; i++)
2001 {
2002 const rdpMcsChannel* channel = &mcs->channels[i];
2003 Stream_Write_UINT16(s, channel->ChannelId);
2004 }
2005
2006 if (mcs->channelCount % 2 == 1)
2007 Stream_Write_UINT16(s, 0);
2008
2009 return TRUE;
2010}
2011
2021BOOL gcc_read_client_cluster_data(wStream* s, rdpMcs* mcs)
2022{
2023 char buffer[128] = WINPR_C_ARRAY_INIT;
2024 UINT32 redirectedSessionId = 0;
2025 rdpSettings* settings = mcs_get_settings(mcs);
2026
2027 WINPR_ASSERT(s);
2028 WINPR_ASSERT(settings);
2029
2030 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
2031 return FALSE;
2032
2033 Stream_Read_UINT32(s, settings->ClusterInfoFlags); /* flags */
2034 Stream_Read_UINT32(s, redirectedSessionId); /* redirectedSessionId */
2035
2036 WLog_Print(mcs->log, WLOG_TRACE, "read ClusterInfoFlags=%s, RedirectedSessionId=0x%08" PRIx32,
2037 rdp_cluster_info_flags_to_string(settings->ClusterInfoFlags, buffer, sizeof(buffer)),
2038 redirectedSessionId);
2039 if (settings->ClusterInfoFlags & REDIRECTED_SESSIONID_FIELD_VALID)
2040 settings->RedirectedSessionId = redirectedSessionId;
2041
2042 settings->ConsoleSession = (settings->ClusterInfoFlags & REDIRECTED_SESSIONID_FIELD_VALID) != 0;
2043 settings->RedirectSmartCards = (settings->ClusterInfoFlags & REDIRECTED_SMARTCARD) != 0;
2044
2045 if (Stream_GetRemainingLength(s) > 0)
2046 {
2047 /* The old Microsoft Mac RDP client can send a pad here */
2048 Stream_Seek(s, Stream_GetRemainingLength(s));
2049 }
2050
2051 return TRUE;
2052}
2053
2063BOOL gcc_write_client_cluster_data(wStream* s, const rdpMcs* mcs)
2064{
2065 char buffer[128] = WINPR_C_ARRAY_INIT;
2066 UINT32 flags = 0;
2067 const rdpSettings* settings = mcs_get_const_settings(mcs);
2068
2069 WINPR_ASSERT(s);
2070 WINPR_ASSERT(settings);
2071
2072 if (!gcc_write_user_data_header(s, CS_CLUSTER, 12))
2073 return FALSE;
2074 flags = settings->ClusterInfoFlags;
2075
2076 if (settings->ConsoleSession || settings->RedirectedSessionId)
2077 flags |= REDIRECTED_SESSIONID_FIELD_VALID;
2078
2079 if (settings->RedirectSmartCards && settings->SmartcardLogon)
2080 flags |= REDIRECTED_SMARTCARD;
2081
2082 if (flags & REDIRECTION_SUPPORTED)
2083 {
2084 /* REDIRECTION_VERSION6 requires multitransport enabled.
2085 * if we run without that use REDIRECTION_VERSION5 */
2086 if (freerdp_settings_get_bool(settings, FreeRDP_SupportMultitransport))
2087 flags |= (REDIRECTION_VERSION6 << 2);
2088 else
2089 flags |= (REDIRECTION_VERSION5 << 2);
2090 }
2091
2092 WLog_Print(mcs->log, WLOG_TRACE, "write ClusterInfoFlags=%s, RedirectedSessionId=0x%08" PRIx32,
2093 rdp_cluster_info_flags_to_string(flags, buffer, sizeof(buffer)),
2094 settings->RedirectedSessionId);
2095 Stream_Write_UINT32(s, flags); /* flags */
2096 Stream_Write_UINT32(s, settings->RedirectedSessionId); /* redirectedSessionID */
2097 return TRUE;
2098}
2099
2109BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs)
2110{
2111 UINT32 monitorCount = 0;
2112 rdpSettings* settings = mcs_get_settings(mcs);
2113
2114 WINPR_ASSERT(s);
2115 WINPR_ASSERT(settings);
2116
2117 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 8))
2118 return FALSE;
2119
2120 Stream_Read_UINT32(s, settings->MonitorFlags); /* flags */
2121 Stream_Read_UINT32(s, monitorCount); /* monitorCount */
2122
2123 /* 2.2.1.3.6 Client Monitor Data -
2124 * monitorCount (4 bytes): A 32-bit, unsigned integer. The number of display
2125 * monitor definitions in the monitorDefArray field (the maximum allowed is 16).
2126 */
2127 if (monitorCount > 16)
2128 {
2129 WLog_Print(mcs->log, WLOG_ERROR, "announced monitors(%" PRIu32 ") exceed the 16 limit",
2130 monitorCount);
2131 return FALSE;
2132 }
2133
2134 if (monitorCount > settings->MonitorDefArraySize)
2135 {
2136 WLog_Print(mcs->log, WLOG_ERROR,
2137 "too many announced monitors(%" PRIu32 "), clamping to %" PRIu32 "",
2138 monitorCount, settings->MonitorDefArraySize);
2139 monitorCount = settings->MonitorDefArraySize;
2140 }
2141
2142 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(mcs->log, s, monitorCount, 20))
2143 return FALSE;
2144
2145 settings->MonitorCount = monitorCount;
2146
2147 for (UINT32 index = 0; index < monitorCount; index++)
2148 {
2149 rdpMonitor* current = &settings->MonitorDefArray[index];
2150
2151 const INT32 left = Stream_Get_INT32(s); /* left */
2152 const INT32 top = Stream_Get_INT32(s); /* top */
2153 const INT32 right = Stream_Get_INT32(s); /* right */
2154 const INT32 bottom = Stream_Get_INT32(s); /* bottom */
2155 const UINT32 flags = Stream_Get_UINT32(s); /* flags */
2156
2157 if ((1ll * left > right) || (1ll * top > bottom))
2158 {
2159 WLog_Print(mcs->log, WLOG_ERROR, "rdpMonitor::rect %dx%d-%dx%d invalid", left, top,
2160 right, bottom);
2161 return FALSE;
2162 }
2163
2164 const INT64 w = 1ll * right - left;
2165 const INT64 h = 1ll * bottom - top;
2166 if ((w >= INT32_MAX) || (h >= INT32_MAX) || (w < 0) || (h < 0))
2167 {
2168 WLog_Print(mcs->log, WLOG_ERROR,
2169 "rdpMonitor::width/height %" PRId64 "/%" PRId64 " invalid", w, h);
2170 return FALSE;
2171 }
2172
2173 current->x = left;
2174 current->y = top;
2175 current->width = WINPR_ASSERTING_INT_CAST(int32_t, w + 1);
2176 current->height = WINPR_ASSERTING_INT_CAST(int32_t, h + 1);
2177 current->is_primary = (flags & MONITOR_PRIMARY) != 0;
2178 }
2179
2180 return TRUE;
2181}
2182
2192BOOL gcc_write_client_monitor_data(wStream* s, const rdpMcs* mcs)
2193{
2194 INT32 baseX = 0;
2195 INT32 baseY = 0;
2196 const rdpSettings* settings = mcs_get_const_settings(mcs);
2197
2198 WINPR_ASSERT(s);
2199 WINPR_ASSERT(settings);
2200
2201 WLog_Print(mcs->log, WLOG_DEBUG, "MonitorCount=%" PRIu32, settings->MonitorCount);
2202 if (settings->MonitorCount > 1)
2203 {
2204 const size_t len = (20 * settings->MonitorCount) + 12;
2205 WINPR_ASSERT(len <= UINT16_MAX);
2206 const UINT16 length = (UINT16)len;
2207 if (!gcc_write_user_data_header(s, CS_MONITOR, length))
2208 return FALSE;
2209 Stream_Write_UINT32(s, settings->MonitorFlags); /* flags */
2210 Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
2211
2212 /* first pass to get the primary monitor coordinates (it is supposed to be
2213 * in (0,0) */
2214 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2215 {
2216 const rdpMonitor* current = &settings->MonitorDefArray[i];
2217 if (current->is_primary)
2218 {
2219 baseX = current->x;
2220 baseY = current->y;
2221 break;
2222 }
2223 }
2224
2225 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2226 {
2227 const rdpMonitor* current = &settings->MonitorDefArray[i];
2228 const INT32 left = current->x - baseX;
2229 const INT32 top = current->y - baseY;
2230 const INT32 right = left + current->width - 1;
2231 const INT32 bottom = top + current->height - 1;
2232 const UINT32 flags = current->is_primary ? MONITOR_PRIMARY : 0;
2233 WLog_Print(mcs->log, WLOG_DEBUG,
2234 "Monitor[%" PRIu32 "]: top=%" PRId32 ", left=%" PRId32 ", bottom=%" PRId32
2235 ", right=%" PRId32 ", flags=%" PRIu32,
2236 i, top, left, bottom, right, flags);
2237 Stream_Write_INT32(s, left); /* left */
2238 Stream_Write_INT32(s, top); /* top */
2239 Stream_Write_INT32(s, right); /* right */
2240 Stream_Write_INT32(s, bottom); /* bottom */
2241 Stream_Write_UINT32(s, flags); /* flags */
2242 }
2243 }
2244 WLog_Print(mcs->log, WLOG_DEBUG, "FINISHED");
2245 return TRUE;
2246}
2247
2248BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs)
2249{
2250 UINT32 monitorCount = 0;
2251 UINT32 monitorAttributeSize = 0;
2252 rdpSettings* settings = mcs_get_settings(mcs);
2253
2254 WINPR_ASSERT(s);
2255 WINPR_ASSERT(settings);
2256
2257 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 12))
2258 return FALSE;
2259
2260 Stream_Read_UINT32(s, settings->MonitorAttributeFlags); /* flags */
2261 Stream_Read_UINT32(s, monitorAttributeSize); /* monitorAttributeSize */
2262 Stream_Read_UINT32(s, monitorCount); /* monitorCount */
2263
2264 if (monitorAttributeSize != 20)
2265 {
2266 WLog_Print(mcs->log, WLOG_ERROR,
2267 "TS_UD_CS_MONITOR_EX::monitorAttributeSize %" PRIu32 " != 20",
2268 monitorAttributeSize);
2269 return FALSE;
2270 }
2271
2272 if (!Stream_CheckAndLogRequiredCapacityOfSizeWLog(mcs->log, s, monitorCount,
2273 monitorAttributeSize))
2274 return FALSE;
2275
2276 if (settings->MonitorCount != monitorCount)
2277 {
2278 WLog_Print(mcs->log, WLOG_ERROR,
2279 "(TS_UD_CS_MONITOR_EX)::monitorCount %" PRIu32 " != expected %" PRIu32,
2280 monitorCount, settings->MonitorCount);
2281 return FALSE;
2282 }
2283
2284 settings->HasMonitorAttributes = TRUE;
2285
2286 for (UINT32 index = 0; index < monitorCount; index++)
2287 {
2288 rdpMonitor* current = &settings->MonitorDefArray[index];
2289 Stream_Read_UINT32(s, current->attributes.physicalWidth); /* physicalWidth */
2290 Stream_Read_UINT32(s, current->attributes.physicalHeight); /* physicalHeight */
2291 Stream_Read_UINT32(s, current->attributes.orientation); /* orientation */
2292 Stream_Read_UINT32(s, current->attributes.desktopScaleFactor); /* desktopScaleFactor */
2293 Stream_Read_UINT32(s, current->attributes.deviceScaleFactor); /* deviceScaleFactor */
2294 }
2295
2296 return TRUE;
2297}
2298
2299BOOL gcc_write_client_monitor_extended_data(wStream* s, const rdpMcs* mcs)
2300{
2301 const rdpSettings* settings = mcs_get_const_settings(mcs);
2302
2303 WINPR_ASSERT(s);
2304 WINPR_ASSERT(settings);
2305
2306 if (settings->HasMonitorAttributes)
2307 {
2308 const size_t length = (20 * settings->MonitorCount) + 16;
2309 WINPR_ASSERT(length <= UINT16_MAX);
2310 if (!gcc_write_user_data_header(s, CS_MONITOR_EX, (UINT16)length))
2311 return FALSE;
2312 Stream_Write_UINT32(s, settings->MonitorAttributeFlags); /* flags */
2313 Stream_Write_UINT32(s, 20); /* monitorAttributeSize */
2314 Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
2315
2316 for (UINT32 i = 0; i < settings->MonitorCount; i++)
2317 {
2318 const rdpMonitor* current = &settings->MonitorDefArray[i];
2319 Stream_Write_UINT32(s, current->attributes.physicalWidth); /* physicalWidth */
2320 Stream_Write_UINT32(s, current->attributes.physicalHeight); /* physicalHeight */
2321 Stream_Write_UINT32(s, current->attributes.orientation); /* orientation */
2322 Stream_Write_UINT32(s, current->attributes.desktopScaleFactor); /* desktopScaleFactor */
2323 Stream_Write_UINT32(s, current->attributes.deviceScaleFactor); /* deviceScaleFactor */
2324 }
2325 }
2326 return TRUE;
2327}
2328
2338BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs)
2339{
2340 WINPR_ASSERT(s);
2341 WINPR_ASSERT(mcs);
2342
2343 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2344 return FALSE;
2345
2346 Stream_Read_UINT32(s, mcs->flags);
2347 mcs->messageChannelId = mcs->baseChannelId++;
2348 return TRUE;
2349}
2350
2360BOOL gcc_write_client_message_channel_data(wStream* s, const rdpMcs* mcs)
2361{
2362 const rdpSettings* settings = mcs_get_const_settings(mcs);
2363
2364 WINPR_ASSERT(s);
2365 WINPR_ASSERT(mcs);
2366 WINPR_ASSERT(settings);
2367 if (freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect) ||
2368 settings->SupportHeartbeatPdu || settings->SupportMultitransport)
2369 {
2370 if (!gcc_write_user_data_header(s, CS_MCS_MSGCHANNEL, 8))
2371 return FALSE;
2372 Stream_Write_UINT32(s, mcs->flags); /* flags */
2373 }
2374 return TRUE;
2375}
2376
2377BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs)
2378{
2379 UINT16 MCSChannelId = 0;
2380 WINPR_ASSERT(s);
2381 WINPR_ASSERT(mcs);
2382 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 2))
2383 return FALSE;
2384
2385 Stream_Read_UINT16(s, MCSChannelId); /* MCSChannelId */
2386 /* Save the MCS message channel id */
2387 mcs->messageChannelId = MCSChannelId;
2388 return TRUE;
2389}
2390
2391BOOL gcc_write_server_message_channel_data(wStream* s, const rdpMcs* mcs)
2392{
2393 WINPR_ASSERT(s);
2394 WINPR_ASSERT(mcs);
2395 if (mcs->messageChannelId == 0)
2396 return TRUE;
2397
2398 if (!gcc_write_user_data_header(s, SC_MCS_MSGCHANNEL, 6))
2399 return FALSE;
2400
2401 Stream_Write_UINT16(s, mcs->messageChannelId); /* mcsChannelId (2 bytes) */
2402 return TRUE;
2403}
2404
2414BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs)
2415{
2416 rdpSettings* settings = mcs_get_settings(mcs);
2417
2418 WINPR_ASSERT(s);
2419 WINPR_ASSERT(settings);
2420
2421 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2422 return FALSE;
2423
2424 UINT32 remoteFlags = 0;
2425 Stream_Read_UINT32(s, remoteFlags);
2426 settings->MultitransportFlags &= remoteFlags; /* merge local and remote flags */
2427 return TRUE;
2428}
2429
2440BOOL gcc_write_client_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
2441{
2442 const rdpSettings* settings = mcs_get_const_settings(mcs);
2443
2444 WINPR_ASSERT(s);
2445 WINPR_ASSERT(settings);
2446 if (!gcc_write_user_data_header(s, CS_MULTITRANSPORT, 8))
2447 return FALSE;
2448 Stream_Write_UINT32(s, settings->MultitransportFlags); /* flags */
2449 return TRUE;
2450}
2451
2452BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs)
2453{
2454 rdpSettings* settings = mcs_get_settings(mcs);
2455 UINT32 remoteFlags = 0;
2456
2457 WINPR_ASSERT(s);
2458 WINPR_ASSERT(settings);
2459 if (!Stream_CheckAndLogRequiredLengthWLog(mcs->log, s, 4))
2460 return FALSE;
2461
2462 Stream_Read_UINT32(s, remoteFlags);
2463 settings->MultitransportFlags &= remoteFlags; /* merge with client setting */
2464 return TRUE;
2465}
2466
2467BOOL gcc_write_server_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
2468{
2469 const rdpSettings* settings = mcs_get_const_settings(mcs);
2470
2471 WINPR_ASSERT(s);
2472 WINPR_ASSERT(settings);
2473
2474 if (!gcc_write_user_data_header(s, SC_MULTITRANSPORT, 8))
2475 return FALSE;
2476
2477 Stream_Write_UINT32(s, settings->MultitransportFlags); /* flags (4 bytes) */
2478 return TRUE;
2479}
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_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
Sets a BOOL settings value.
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_pointer_len
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:1431
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:4088
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_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_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:2363
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.
freerdp_settings_set_string
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:3729
rdpMonitor
Definition settings_types.h:431