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