FreeRDP
Loading...
Searching...
No Matches
rdp.c
1
21#include <freerdp/config.h>
22
23#include "settings.h"
24
25#include <winpr/crt.h>
26#include <winpr/string.h>
27#include <winpr/synch.h>
28#include <winpr/assert.h>
29#include <winpr/cast.h>
30#include <winpr/json.h>
31
32#include "rdp.h"
33
34#include "state.h"
35#include "info.h"
36#include "utils.h"
37#include "mcs.h"
38#include "redirection.h"
39
40#include <freerdp/codec/bulk.h>
41#include <freerdp/crypto/per.h>
42#include <freerdp/log.h>
43#include <freerdp/buildflags.h>
44
45#define RDP_TAG FREERDP_TAG("core.rdp")
46
47typedef struct
48{
49 const char* file;
50 const char* fkt;
51 size_t line;
52 DWORD level;
53} log_line_t;
54
55static const char* DATA_PDU_TYPE_STRINGS[80] = {
56 "?",
57 "?", /* 0x00 - 0x01 */
58 "Update", /* 0x02 */
59 "?",
60 "?",
61 "?",
62 "?",
63 "?",
64 "?",
65 "?",
66 "?", /* 0x03 - 0x0A */
67 "?",
68 "?",
69 "?",
70 "?",
71 "?",
72 "?",
73 "?",
74 "?",
75 "?", /* 0x0B - 0x13 */
76 "Control", /* 0x14 */
77 "?",
78 "?",
79 "?",
80 "?",
81 "?",
82 "?", /* 0x15 - 0x1A */
83 "Pointer", /* 0x1B */
84 "Input", /* 0x1C */
85 "?",
86 "?", /* 0x1D - 0x1E */
87 "Synchronize", /* 0x1F */
88 "?", /* 0x20 */
89 "Refresh Rect", /* 0x21 */
90 "Play Sound", /* 0x22 */
91 "Suppress Output", /* 0x23 */
92 "Shutdown Request", /* 0x24 */
93 "Shutdown Denied", /* 0x25 */
94 "Save Session Info", /* 0x26 */
95 "Font List", /* 0x27 */
96 "Font Map", /* 0x28 */
97 "Set Keyboard Indicators", /* 0x29 */
98 "?", /* 0x2A */
99 "Bitmap Cache Persistent List", /* 0x2B */
100 "Bitmap Cache Error", /* 0x2C */
101 "Set Keyboard IME Status", /* 0x2D */
102 "Offscreen Cache Error", /* 0x2E */
103 "Set Error Info", /* 0x2F */
104 "Draw Nine Grid Error", /* 0x30 */
105 "Draw GDI+ Error", /* 0x31 */
106 "ARC Status", /* 0x32 */
107 "?",
108 "?",
109 "?", /* 0x33 - 0x35 */
110 "Status Info", /* 0x36 */
111 "Monitor Layout", /* 0x37 */
112 "FrameAcknowledge",
113 "?",
114 "?", /* 0x38 - 0x40 */
115 "?",
116 "?",
117 "?",
118 "?",
119 "?",
120 "?" /* 0x41 - 0x46 */
121};
122
123#define rdp_check_monitor_layout_pdu_state(rdp, expected) \
124 rdp_check_monitor_layout_pdu_state_(rdp, expected, __FILE__, __func__, __LINE__)
125
126static BOOL rdp_check_monitor_layout_pdu_state_(const rdpRdp* rdp, BOOL expected, const char* file,
127 const char* fkt, size_t line)
128{
129 WINPR_ASSERT(rdp);
130 if (expected != rdp->monitor_layout_pdu)
131 {
132 const DWORD log_level = WLOG_ERROR;
133 if (WLog_IsLevelActive(rdp->log, log_level))
134 {
135 WLog_PrintTextMessage(rdp->log, log_level, line, file, fkt,
136 "Expected rdp->monitor_layout_pdu == %s",
137 expected ? "TRUE" : "FALSE");
138 }
139 return FALSE;
140 }
141 return TRUE;
142}
143
144#define rdp_set_monitor_layout_pdu_state(rdp, expected) \
145 rdp_set_monitor_layout_pdu_state_(rdp, expected, __FILE__, __func__, __LINE__)
146static BOOL rdp_set_monitor_layout_pdu_state_(rdpRdp* rdp, BOOL value, const char* file,
147 const char* fkt, size_t line)
148{
149
150 WINPR_ASSERT(rdp);
151 if (value && (value == rdp->monitor_layout_pdu))
152 {
153 const DWORD log_level = WLOG_WARN;
154 if (WLog_IsLevelActive(rdp->log, log_level))
155 {
156 WLog_PrintTextMessage(rdp->log, log_level, line, file, fkt,
157 "rdp->monitor_layout_pdu == TRUE, expected FALSE");
158 }
159 return FALSE;
160 }
161 rdp->monitor_layout_pdu = value;
162 return TRUE;
163}
164
165const char* data_pdu_type_to_string(UINT8 type)
166{
167 if (type >= ARRAYSIZE(DATA_PDU_TYPE_STRINGS))
168 return "???";
169 return DATA_PDU_TYPE_STRINGS[type];
170}
171
172static BOOL rdp_read_flow_control_pdu(rdpRdp* rdp, wStream* s, UINT16* type, UINT16* channel_id);
173static BOOL rdp_write_share_control_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 type,
174 UINT16 channel_id);
175static BOOL rdp_write_share_data_header(rdpRdp* rdp, wStream* s, size_t length, BYTE type,
176 UINT32 share_id);
177
188BOOL rdp_read_security_header(rdpRdp* rdp, wStream* s, UINT16* flags, UINT16* length)
189{
190 char buffer[256] = { 0 };
191 WINPR_ASSERT(s);
192 WINPR_ASSERT(flags);
193 WINPR_ASSERT(rdp);
194
195 /* Basic Security Header */
196 if ((length && (*length < 4)))
197 {
198 WLog_Print(rdp->log, WLOG_WARN,
199 "invalid security header length, have %" PRIu16 ", must be >= 4", *length);
200 return FALSE;
201 }
202 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
203 return FALSE;
204
205 *flags = Stream_Get_UINT16(s); /* flags */
206 const uint16_t flagsHi = Stream_Get_UINT16(s); /* flagsHi (unused) */
207 if ((*flags & SEC_FLAGSHI_VALID) != 0)
208 {
209 WLog_Print(rdp->log, WLOG_WARN,
210 "[MS-RDPBCGR] 2.2.8.1.1.2.1 Basic (TS_SECURITY_HEADER) SEC_FLAGSHI_VALID field "
211 "set: flagsHi=0x%04" PRIx16,
212 flagsHi);
213 }
214 WLog_Print(rdp->log, WLOG_TRACE, "%s",
215 rdp_security_flag_string(*flags, buffer, sizeof(buffer)));
216 if (length)
217 *length -= 4;
218
219 return TRUE;
220}
221
231BOOL rdp_write_security_header(rdpRdp* rdp, wStream* s, UINT16 flags)
232{
233 char buffer[256] = { 0 };
234 WINPR_ASSERT(s);
235 WINPR_ASSERT(rdp);
236
237 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 4))
238 return FALSE;
239
240 WLog_Print(rdp->log, WLOG_TRACE, "%s", rdp_security_flag_string(flags, buffer, sizeof(buffer)));
241 /* Basic Security Header */
242 WINPR_ASSERT((flags & SEC_FLAGSHI_VALID) == 0); /* SEC_FLAGSHI_VALID is unsupported */
243 Stream_Write_UINT16(s, flags); /* flags */
244 Stream_Write_UINT16(s, 0); /* flagsHi (unused) */
245 return TRUE;
246}
247
248BOOL rdp_read_share_control_header(rdpRdp* rdp, wStream* s, UINT16* tpktLength,
249 UINT16* remainingLength, UINT16* type, UINT16* channel_id)
250{
251 UINT16 len = 0;
252 UINT16 tmp = 0;
253
254 WINPR_ASSERT(rdp);
255 WINPR_ASSERT(s);
256 WINPR_ASSERT(type);
257 WINPR_ASSERT(channel_id);
258
259 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
260 return FALSE;
261
262 /* Share Control Header */
263 Stream_Read_UINT16(s, len); /* totalLength */
264
265 /* If length is 0x8000 then we actually got a flow control PDU that we should ignore
266 http://msdn.microsoft.com/en-us/library/cc240576.aspx */
267 if (len == 0x8000)
268 {
269 if (!rdp_read_flow_control_pdu(rdp, s, type, channel_id))
270 return FALSE;
271 *channel_id = 0;
272 if (tpktLength)
273 *tpktLength = 8; /* Flow control PDU is 8 bytes */
274 if (remainingLength)
275 *remainingLength = 0;
276
277 char buffer[128] = { 0 };
278 WLog_Print(rdp->log, WLOG_DEBUG,
279 "[Flow control PDU] type=%s, tpktLength=%" PRIu16 ", remainingLength=%" PRIu16,
280 pdu_type_to_str(*type, buffer, sizeof(buffer)), tpktLength ? *tpktLength : 0u,
281 remainingLength ? *remainingLength : 0u);
282 return TRUE;
283 }
284
285 if (len < 4U)
286 {
287 WLog_Print(rdp->log, WLOG_ERROR,
288 "Invalid share control header, length is %" PRIu16 ", must be >4", len);
289 return FALSE;
290 }
291
292 if (tpktLength)
293 *tpktLength = len;
294
295 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
296 return FALSE;
297
298 Stream_Read_UINT16(s, tmp); /* pduType */
299 *type = tmp & 0x0F; /* type is in the 4 least significant bits */
300
301 size_t remLen = len - 4;
302 if (len > 5)
303 {
304 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 2))
305 return FALSE;
306
307 Stream_Read_UINT16(s, *channel_id); /* pduSource */
308 remLen = len - 6;
309 }
310 else
311 *channel_id = 0; /* Windows XP can send such short DEACTIVATE_ALL PDUs. */
312
313 char buffer[128] = { 0 };
314 WLog_Print(rdp->log, WLOG_DEBUG, "type=%s, tpktLength=%" PRIu16 ", remainingLength=%" PRIuz,
315 pdu_type_to_str(*type, buffer, sizeof(buffer)), len, remLen);
316 if (remainingLength)
317 {
318 WINPR_ASSERT(remLen <= UINT16_MAX);
319 *remainingLength = (UINT16)remLen;
320 }
321 return Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, remLen);
322}
323
324BOOL rdp_write_share_control_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 type,
325 UINT16 channel_id)
326{
327 WINPR_ASSERT(s);
328 WINPR_ASSERT(rdp);
329 if (length > UINT16_MAX)
330 return FALSE;
331
332 if (length < RDP_PACKET_HEADER_MAX_LENGTH)
333 return FALSE;
334 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 6))
335 return FALSE;
336 length -= RDP_PACKET_HEADER_MAX_LENGTH;
337 /* Share Control Header */
338 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* totalLength */
339 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, type | 0x10)); /* pduType */
340 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, channel_id)); /* pduSource */
341 return TRUE;
342}
343
344BOOL rdp_read_share_data_header(rdpRdp* rdp, wStream* s, UINT16* length, BYTE* type,
345 UINT32* shareId, BYTE* compressedType, UINT16* compressedLength)
346{
347 WINPR_ASSERT(s);
348 WINPR_ASSERT(rdp);
349
350 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 12))
351 return FALSE;
352
353 /* Share Data Header */
354 Stream_Read_UINT32(s, *shareId); /* shareId (4 bytes) */
355 Stream_Seek_UINT8(s); /* pad1 (1 byte) */
356 Stream_Seek_UINT8(s); /* streamId (1 byte) */
357 Stream_Read_UINT16(s, *length); /* uncompressedLength (2 bytes) */
358 Stream_Read_UINT8(s, *type); /* pduType2, Data PDU Type (1 byte) */
359 Stream_Read_UINT8(s, *compressedType); /* compressedType (1 byte) */
360 Stream_Read_UINT16(s, *compressedLength); /* compressedLength (2 bytes) */
361 return TRUE;
362}
363
364BOOL rdp_write_share_data_header(rdpRdp* rdp, wStream* s, size_t length, BYTE type, UINT32 share_id)
365{
366 const size_t headerLen = RDP_PACKET_HEADER_MAX_LENGTH + RDP_SHARE_CONTROL_HEADER_LENGTH +
367 RDP_SHARE_DATA_HEADER_LENGTH;
368
369 WINPR_ASSERT(s);
370 WINPR_ASSERT(rdp);
371 if (length > UINT16_MAX)
372 return FALSE;
373
374 if (length < headerLen)
375 return FALSE;
376 length -= headerLen;
377 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, (s), 12))
378 return FALSE;
379
380 /* Share Data Header */
381 Stream_Write_UINT32(s, share_id); /* shareId (4 bytes) */
382 Stream_Write_UINT8(s, 0); /* pad1 (1 byte) */
383 Stream_Write_UINT8(s, STREAM_LOW); /* streamId (1 byte) */
384 Stream_Write_UINT16(
385 s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* uncompressedLength (2 bytes) */
386 Stream_Write_UINT8(s, type); /* pduType2, Data PDU Type (1 byte) */
387 Stream_Write_UINT8(s, 0); /* compressedType (1 byte) */
388 Stream_Write_UINT16(s, 0); /* compressedLength (2 bytes) */
389 return TRUE;
390}
391
392static BOOL rdp_security_stream_init(rdpRdp* rdp, wStream* s, BOOL sec_header, UINT16* sec_flags)
393{
394 WINPR_ASSERT(rdp);
395 WINPR_ASSERT(s);
396 WINPR_ASSERT(sec_flags);
397
398 if (rdp->do_crypt)
399 {
400 if (!Stream_SafeSeek(s, 12))
401 return FALSE;
402
403 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
404 {
405 if (!Stream_SafeSeek(s, 4))
406 return FALSE;
407 }
408
409 *sec_flags |= SEC_ENCRYPT;
410
411 if (rdp->do_secure_checksum)
412 *sec_flags |= SEC_SECURE_CHECKSUM;
413 }
414 else if (*sec_flags != 0 || sec_header)
415 {
416 if (!Stream_SafeSeek(s, 4))
417 return FALSE;
418 }
419
420 return TRUE;
421}
422
423wStream* rdp_send_stream_init(rdpRdp* rdp, UINT16* sec_flags)
424{
425 wStream* s = NULL;
426
427 WINPR_ASSERT(rdp);
428 WINPR_ASSERT(rdp->transport);
429
430 s = transport_send_stream_init(rdp->transport, 4096);
431
432 if (!s)
433 return NULL;
434
435 if (!Stream_SafeSeek(s, RDP_PACKET_HEADER_MAX_LENGTH))
436 goto fail;
437
438 if (!rdp_security_stream_init(rdp, s, FALSE, sec_flags))
439 goto fail;
440
441 return s;
442fail:
443 Stream_Release(s);
444 return NULL;
445}
446
447wStream* rdp_send_stream_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
448{
449 wStream* s = rdp_send_stream_init(rdp, sec_flags);
450
451 if (!s)
452 return NULL;
453
454 if (!Stream_SafeSeek(s, RDP_SHARE_CONTROL_HEADER_LENGTH))
455 goto fail;
456
457 return s;
458fail:
459 Stream_Release(s);
460 return NULL;
461}
462
463wStream* rdp_data_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
464{
465 wStream* s = rdp_send_stream_pdu_init(rdp, sec_flags);
466
467 if (!s)
468 return NULL;
469
470 if (!Stream_SafeSeek(s, RDP_SHARE_DATA_HEADER_LENGTH))
471 goto fail;
472
473 return s;
474fail:
475 Stream_Release(s);
476 return NULL;
477}
478
479BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo)
480{
481 WINPR_ASSERT(rdp);
482
483 rdp->errorInfo = errorInfo;
484
485 if (rdp->errorInfo != ERRINFO_SUCCESS)
486 {
487 rdpContext* context = rdp->context;
488 WINPR_ASSERT(context);
489
490 rdp_print_errinfo(rdp->errorInfo);
491
492 if (context)
493 {
494 freerdp_set_last_error_log(context, MAKE_FREERDP_ERROR(ERRINFO, errorInfo));
495
496 if (context->pubSub)
497 {
498 ErrorInfoEventArgs e = { 0 };
499 EventArgsInit(&e, "freerdp");
500 e.code = rdp->errorInfo;
501 PubSub_OnErrorInfo(context->pubSub, context, &e);
502 }
503 }
504 else
505 WLog_Print(rdp->log, WLOG_ERROR, "missing context=%p", (void*)context);
506 }
507 else
508 {
509 freerdp_set_last_error_log(rdp->context, FREERDP_ERROR_SUCCESS);
510 }
511
512 return TRUE;
513}
514
515wStream* rdp_message_channel_pdu_init(rdpRdp* rdp, UINT16* sec_flags)
516{
517 wStream* s = NULL;
518
519 WINPR_ASSERT(rdp);
520
521 s = transport_send_stream_init(rdp->transport, 4096);
522
523 if (!s)
524 return NULL;
525
526 if (!Stream_SafeSeek(s, RDP_PACKET_HEADER_MAX_LENGTH))
527 goto fail;
528
529 if (!rdp_security_stream_init(rdp, s, TRUE, sec_flags))
530 goto fail;
531
532 return s;
533fail:
534 Stream_Release(s);
535 return NULL;
536}
537
548BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId)
549{
550 BYTE li = 0;
551 BYTE code = 0;
552 BYTE choice = 0;
553 UINT16 initiator = 0;
554
555 WINPR_ASSERT(rdp);
556 WINPR_ASSERT(rdp->settings);
557 WINPR_ASSERT(s);
558 DomainMCSPDU MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataRequest
559 : DomainMCSPDU_SendDataIndication;
560
561 *channelId = 0; /* Initialize in case of early abort */
562 if (!tpkt_read_header(s, length))
563 return FALSE;
564
565 if (!tpdu_read_header(s, &code, &li, *length))
566 return FALSE;
567
568 if (code != X224_TPDU_DATA)
569 {
570 if (code == X224_TPDU_DISCONNECT_REQUEST)
571 {
572 WLog_Print(rdp->log, WLOG_WARN, "Received X224_TPDU_DISCONNECT_REQUEST, terminating");
573 utils_abort_connect(rdp);
574 return TRUE;
575 }
576
577 WLog_Print(rdp->log, WLOG_WARN,
578 "Unexpected X224 TPDU type %s [%08" PRIx32 "] instead of %s",
579 tpdu_type_to_string(code), code, tpdu_type_to_string(X224_TPDU_DATA));
580 return FALSE;
581 }
582
583 if (!per_read_choice(s, &choice))
584 return FALSE;
585
586 const DomainMCSPDU domainMCSPDU = (DomainMCSPDU)(choice >> 2);
587
588 if (domainMCSPDU != MCSPDU)
589 {
590 if (domainMCSPDU != DomainMCSPDU_DisconnectProviderUltimatum)
591 {
592 WLog_Print(rdp->log, WLOG_WARN, "Received %s instead of %s",
593 mcs_domain_pdu_string(domainMCSPDU), mcs_domain_pdu_string(MCSPDU));
594 return FALSE;
595 }
596 }
597
598 MCSPDU = domainMCSPDU;
599
600 if (*length < 8U)
601 {
602 WLog_Print(rdp->log, WLOG_WARN, "TPDU invalid length, got %" PRIu16 ", expected at least 8",
603 *length);
604 return FALSE;
605 }
606
607 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, *length - 8))
608 return FALSE;
609
610 if (MCSPDU == DomainMCSPDU_DisconnectProviderUltimatum)
611 {
612 int reason = 0;
613 TerminateEventArgs e = { 0 };
614
615 if (!mcs_recv_disconnect_provider_ultimatum(rdp->mcs, s, &reason))
616 return FALSE;
617
618 rdpContext* context = rdp->context;
619 WINPR_ASSERT(context);
620 context->disconnectUltimatum = reason;
621
622 if (rdp->errorInfo == ERRINFO_SUCCESS)
623 {
629 UINT32 errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
630 if (reason == Disconnect_Ultimatum_provider_initiated)
631 errorInfo = ERRINFO_RPC_INITIATED_DISCONNECT;
632 else if (reason == Disconnect_Ultimatum_user_requested)
633 errorInfo = ERRINFO_LOGOFF_BY_USER;
634
635 rdp_set_error_info(rdp, errorInfo);
636 }
637
638 WLog_Print(rdp->log, WLOG_DEBUG, "DisconnectProviderUltimatum: reason: %d", reason);
639 utils_abort_connect(rdp);
640 EventArgsInit(&e, "freerdp");
641 e.code = 0;
642 PubSub_OnTerminate(rdp->pubSub, context, &e);
643 return TRUE;
644 }
645
646 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 5))
647 return FALSE;
648
649 if (!per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID)) /* initiator (UserId) */
650 return FALSE;
651
652 if (!per_read_integer16(s, channelId, 0)) /* channelId */
653 return FALSE;
654
655 const uint8_t dataPriority = Stream_Get_UINT8(s); /* dataPriority + Segmentation (0x70) */
656 WLog_Print(rdp->log, WLOG_TRACE, "dataPriority=%" PRIu8, dataPriority);
657
658 if (!per_read_length(s, length)) /* userData (OCTET_STRING) */
659 return FALSE;
660
661 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, *length))
662 return FALSE;
663
664 return TRUE;
665}
666
677BOOL rdp_write_header(rdpRdp* rdp, wStream* s, size_t length, UINT16 channelId, UINT16 sec_flags)
678{
679 WINPR_ASSERT(rdp);
680 WINPR_ASSERT(rdp->settings);
681 WINPR_ASSERT(s);
682 WINPR_ASSERT(length >= RDP_PACKET_HEADER_MAX_LENGTH);
683 if (length > UINT16_MAX)
684 return FALSE;
685
686 DomainMCSPDU MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataIndication
687 : DomainMCSPDU_SendDataRequest;
688
689 if ((sec_flags & SEC_ENCRYPT) && (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS))
690 {
691 const UINT16 body_length = (UINT16)length - RDP_PACKET_HEADER_MAX_LENGTH;
692 const UINT16 pad = 8 - (body_length % 8);
693
694 if (pad != 8)
695 length += pad;
696 }
697
698 if (!mcs_write_domain_mcspdu_header(s, MCSPDU, (UINT16)length, 0))
699 return FALSE;
700 if (!per_write_integer16(s, rdp->mcs->userId, MCS_BASE_CHANNEL_ID)) /* initiator */
701 return FALSE;
702 if (!per_write_integer16(s, channelId, 0)) /* channelId */
703 return FALSE;
704 if (!Stream_EnsureRemainingCapacity(s, 3))
705 return FALSE;
706 Stream_Write_UINT8(s, 0x70); /* dataPriority + segmentation */
707 /*
708 * We always encode length in two bytes, even though we could use
709 * only one byte if length <= 0x7F. It is just easier that way,
710 * because we can leave room for fixed-length header, store all
711 * the data first and then store the header.
712 */
713 length = (length - RDP_PACKET_HEADER_MAX_LENGTH) | 0x8000;
714 Stream_Write_UINT16_BE(
715 s, WINPR_ASSERTING_INT_CAST(uint16_t, length)); /* userData (OCTET_STRING) */
716 return TRUE;
717}
718
719static BOOL rdp_security_stream_out(rdpRdp* rdp, wStream* s, size_t length, UINT16 sec_flags,
720 UINT32* pad)
721{
722 BOOL status = 0;
723 WINPR_ASSERT(rdp);
724 if (length > UINT16_MAX)
725 return FALSE;
726
727 *pad = 0;
728
729 if (sec_flags != 0)
730 {
731 WINPR_ASSERT(sec_flags <= UINT16_MAX);
732 if (!rdp_write_security_header(rdp, s, sec_flags))
733 return FALSE;
734
735 if (sec_flags & SEC_ENCRYPT)
736 {
737 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
738 {
739 BYTE* data = Stream_PointerAs(s, BYTE) + 12;
740 const size_t size = WINPR_ASSERTING_INT_CAST(size_t, (data - Stream_Buffer(s)));
741 if (size > length)
742 return FALSE;
743
744 length -= size;
745
746 Stream_Write_UINT16(s, 0x10); /* length */
747 Stream_Write_UINT8(s, 0x1); /* TSFIPS_VERSION 1*/
748 /* handle padding */
749 *pad = 8 - (length % 8);
750
751 if (*pad == 8)
752 *pad = 0;
753
754 if (*pad)
755 memset(data + length, 0, *pad);
756
757 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, *pad));
758
759 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8))
760 return FALSE;
761 if (!security_hmac_signature(data, length, Stream_Pointer(s), 8, rdp))
762 return FALSE;
763
764 Stream_Seek(s, 8);
765 if (!security_fips_encrypt(data, length + *pad, rdp))
766 return FALSE;
767 }
768 else
769 {
770 const BYTE* data = Stream_PointerAs(s, const BYTE) + 8;
771 const size_t diff = Stream_GetPosition(s) + 8ULL;
772 if (diff > length)
773 return FALSE;
774 length -= diff;
775
776 if (!Stream_CheckAndLogRequiredCapacityWLog(rdp->log, s, 8))
777 return FALSE;
778 if (sec_flags & SEC_SECURE_CHECKSUM)
779 status = security_salted_mac_signature(rdp, data, (UINT32)length, TRUE,
780 Stream_Pointer(s), 8);
781 else
782 status = security_mac_signature(rdp, data, (UINT32)length,
783 Stream_PointerAs(s, BYTE), 8);
784
785 if (!status)
786 return FALSE;
787
788 Stream_Seek(s, 8);
789
790 if (!security_encrypt(Stream_Pointer(s), length, rdp))
791 return FALSE;
792 }
793 }
794 }
795
796 return TRUE;
797}
798
799static UINT32 rdp_get_sec_bytes(rdpRdp* rdp, UINT16 sec_flags)
800{
801 UINT32 sec_bytes = 0;
802
803 if (sec_flags & SEC_ENCRYPT)
804 {
805 sec_bytes = 12;
806
807 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
808 sec_bytes += 4;
809 }
810 else if (sec_flags != 0)
811 {
812 sec_bytes = 4;
813 }
814 else
815 {
816 sec_bytes = 0;
817 }
818
819 return sec_bytes;
820}
821
829BOOL rdp_send(rdpRdp* rdp, wStream* s, UINT16 channel_id, UINT16 sec_flags)
830{
831 BOOL rc = FALSE;
832 UINT32 pad = 0;
833 BOOL should_unlock = FALSE;
834
835 if (!s)
836 return FALSE;
837
838 if (!rdp)
839 goto fail;
840
841 if (sec_flags & SEC_ENCRYPT)
842 {
843 if (!security_lock(rdp))
844 goto fail;
845 should_unlock = TRUE;
846 }
847
848 {
849 size_t length = Stream_GetPosition(s);
850 Stream_SetPosition(s, 0);
851 if (!rdp_write_header(rdp, s, length, channel_id, sec_flags))
852 goto fail;
853
854 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
855 goto fail;
856
857 length += pad;
858 Stream_SetPosition(s, length);
859 Stream_SealLength(s);
860 }
861
862 if (transport_write(rdp->transport, s) < 0)
863 goto fail;
864
865 rc = TRUE;
866fail:
867 if (should_unlock && !security_unlock(rdp))
868 rc = FALSE;
869 Stream_Release(s);
870 return rc;
871}
872
873BOOL rdp_send_pdu(rdpRdp* rdp, wStream* s, UINT16 type, UINT16 channel_id, UINT16 sec_flags)
874{
875 BOOL rc = FALSE;
876 UINT32 sec_bytes = 0;
877 size_t sec_hold = 0;
878 UINT32 pad = 0;
879 BOOL should_unlock = FALSE;
880
881 if (!s)
882 return FALSE;
883
884 if (!rdp)
885 goto fail;
886
887 if (sec_flags & SEC_ENCRYPT)
888 {
889 if (!security_lock(rdp))
890 goto fail;
891 should_unlock = TRUE;
892 }
893
894 {
895 size_t length = Stream_GetPosition(s);
896 Stream_SetPosition(s, 0);
897 if (!rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID, sec_flags))
898 goto fail;
899 sec_bytes = rdp_get_sec_bytes(rdp, sec_flags);
900 sec_hold = Stream_GetPosition(s);
901 Stream_Seek(s, sec_bytes);
902 if (!rdp_write_share_control_header(rdp, s, length - sec_bytes, type, channel_id))
903 goto fail;
904 Stream_SetPosition(s, sec_hold);
905
906 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
907 goto fail;
908
909 length += pad;
910 Stream_SetPosition(s, length);
911 Stream_SealLength(s);
912 }
913
914 if (transport_write(rdp->transport, s) < 0)
915 goto fail;
916
917 rc = TRUE;
918fail:
919 if (should_unlock && !security_unlock(rdp))
920 rc = FALSE;
921 return rc;
922}
923
924BOOL rdp_send_data_pdu(rdpRdp* rdp, wStream* s, BYTE type, UINT16 channel_id, UINT16 sec_flags)
925{
926 BOOL rc = FALSE;
927 UINT32 sec_bytes = 0;
928 size_t sec_hold = 0;
929 UINT32 pad = 0;
930 BOOL should_unlock = FALSE;
931
932 if (!s)
933 return FALSE;
934
935 if (!rdp)
936 goto fail;
937
938 if (sec_flags & SEC_ENCRYPT)
939 {
940 if (!security_lock(rdp))
941 goto fail;
942 should_unlock = TRUE;
943 }
944
945 {
946 size_t length = Stream_GetPosition(s);
947 Stream_SetPosition(s, 0);
948 if (!rdp_write_header(rdp, s, length, MCS_GLOBAL_CHANNEL_ID, sec_flags))
949 goto fail;
950 sec_bytes = rdp_get_sec_bytes(rdp, sec_flags);
951 sec_hold = Stream_GetPosition(s);
952 Stream_Seek(s, sec_bytes);
953 if (!rdp_write_share_control_header(rdp, s, length - sec_bytes, PDU_TYPE_DATA, channel_id))
954 goto fail;
955 if (!rdp_write_share_data_header(rdp, s, length - sec_bytes, type, rdp->settings->ShareId))
956 goto fail;
957 Stream_SetPosition(s, sec_hold);
958
959 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
960 goto fail;
961
962 length += pad;
963 Stream_SetPosition(s, length);
964 Stream_SealLength(s);
965 }
966 WLog_Print(rdp->log, WLOG_DEBUG,
967 "sending data (type=0x%x size=%" PRIuz " channelId=%" PRIu16 ")", type,
968 Stream_Length(s), channel_id);
969
970 rdp->outPackets++;
971 if (transport_write(rdp->transport, s) < 0)
972 goto fail;
973
974 rc = TRUE;
975fail:
976 if (should_unlock && !security_unlock(rdp))
977 rc = FALSE;
978 Stream_Release(s);
979 return rc;
980}
981
982BOOL rdp_send_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 sec_flags)
983{
984 BOOL rc = FALSE;
985 UINT32 pad = 0;
986 BOOL should_unlock = FALSE;
987
988 WINPR_ASSERT(rdp);
989 WINPR_ASSERT(s);
990
991 if (sec_flags & SEC_ENCRYPT)
992 {
993 if (!security_lock(rdp))
994 goto fail;
995 should_unlock = TRUE;
996 }
997
998 {
999 size_t length = Stream_GetPosition(s);
1000 Stream_SetPosition(s, 0);
1001 if (!rdp_write_header(rdp, s, length, rdp->mcs->messageChannelId, sec_flags))
1002 goto fail;
1003
1004 if (!rdp_security_stream_out(rdp, s, length, sec_flags, &pad))
1005 goto fail;
1006
1007 length += pad;
1008 Stream_SetPosition(s, length);
1009 }
1010 Stream_SealLength(s);
1011
1012 if (transport_write(rdp->transport, s) < 0)
1013 goto fail;
1014
1015 rc = TRUE;
1016fail:
1017 if (should_unlock && !security_unlock(rdp))
1018 rc = FALSE;
1019 Stream_Release(s);
1020 return rc;
1021}
1022
1023static BOOL rdp_recv_server_shutdown_denied_pdu(WINPR_ATTR_UNUSED rdpRdp* rdp,
1024 WINPR_ATTR_UNUSED wStream* s)
1025{
1026 return TRUE;
1027}
1028
1029static BOOL rdp_recv_server_set_keyboard_indicators_pdu(rdpRdp* rdp, wStream* s)
1030{
1031 WINPR_ASSERT(rdp);
1032 WINPR_ASSERT(s);
1033
1034 rdpContext* context = rdp->context;
1035 WINPR_ASSERT(context);
1036 WINPR_ASSERT(context->update);
1037
1038 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1039 return FALSE;
1040
1041 const uint16_t unitId = Stream_Get_UINT16(s); /* unitId (2 bytes) */
1042 if (unitId != 0)
1043 {
1044 WLog_Print(rdp->log, WLOG_WARN,
1045 "[MS-RDPBCGR] 2.2.8.2.1.1 Set Keyboard Indicators PDU Data "
1046 "(TS_SET_KEYBOARD_INDICATORS_PDU)::unitId should be 0, is %" PRIu16,
1047 unitId);
1048 }
1049 const UINT16 ledFlags = Stream_Get_UINT16(s); /* ledFlags (2 bytes) */
1050 return IFCALLRESULT(TRUE, context->update->SetKeyboardIndicators, context, ledFlags);
1051}
1052
1053static BOOL rdp_recv_server_set_keyboard_ime_status_pdu(rdpRdp* rdp, wStream* s)
1054{
1055 if (!rdp || !rdp->input)
1056 return FALSE;
1057
1058 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 10))
1059 return FALSE;
1060
1061 const uint16_t unitId = Stream_Get_UINT16(s); /* unitId (2 bytes) */
1062 if (unitId != 0)
1063 {
1064 WLog_Print(rdp->log, WLOG_WARN,
1065 "[MS-RDPBCGR] 2.2.8.2.2.1 Set Keyboard IME Status PDU Data "
1066 "(TS_SET_KEYBOARD_IME_STATUS_PDU)::unitId should be 0, is %" PRIu16,
1067 unitId);
1068 }
1069 const uint32_t imeState = Stream_Get_UINT32(s); /* imeState (4 bytes) */
1070 const uint32_t imeConvMode = Stream_Get_UINT32(s); /* imeConvMode (4 bytes) */
1071 return IFCALLRESULT(TRUE, rdp->update->SetKeyboardImeStatus, rdp->context, unitId, imeState,
1072 imeConvMode);
1073}
1074
1075static BOOL rdp_recv_set_error_info_data_pdu(rdpRdp* rdp, wStream* s)
1076{
1077 UINT32 errorInfo = 0;
1078
1079 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1080 return FALSE;
1081
1082 Stream_Read_UINT32(s, errorInfo); /* errorInfo (4 bytes) */
1083 return rdp_set_error_info(rdp, errorInfo);
1084}
1085
1086static BOOL rdp_recv_server_auto_reconnect_status_pdu(rdpRdp* rdp, wStream* s)
1087{
1088 UINT32 arcStatus = 0;
1089
1090 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1091 return FALSE;
1092
1093 Stream_Read_UINT32(s, arcStatus); /* arcStatus (4 bytes) */
1094 WLog_Print(rdp->log, WLOG_WARN, "AutoReconnectStatus: 0x%08" PRIX32 "", arcStatus);
1095 return TRUE;
1096}
1097
1098static BOOL rdp_recv_server_status_info_pdu(rdpRdp* rdp, wStream* s)
1099{
1100 UINT32 statusCode = 0;
1101
1102 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1103 return FALSE;
1104
1105 Stream_Read_UINT32(s, statusCode); /* statusCode (4 bytes) */
1106
1107 if (rdp->update->ServerStatusInfo)
1108 return rdp->update->ServerStatusInfo(rdp->context, statusCode);
1109
1110 return TRUE;
1111}
1112
1113static BOOL rdp_recv_monitor_layout_pdu(rdpRdp* rdp, wStream* s)
1114{
1115 UINT32 monitorCount = 0;
1116 MONITOR_DEF* monitorDefArray = NULL;
1117 BOOL ret = TRUE;
1118
1119 WINPR_ASSERT(rdp);
1120 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 4))
1121 return FALSE;
1122
1123 Stream_Read_UINT32(s, monitorCount); /* monitorCount (4 bytes) */
1124
1125 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(rdp->log, s, monitorCount, 20ull))
1126 return FALSE;
1127
1128 monitorDefArray = (MONITOR_DEF*)calloc(monitorCount, sizeof(MONITOR_DEF));
1129
1130 if (!monitorDefArray)
1131 return FALSE;
1132
1133 for (UINT32 index = 0; index < monitorCount; index++)
1134 {
1135 MONITOR_DEF* monitor = &monitorDefArray[index];
1136 Stream_Read_INT32(s, monitor->left); /* left (4 bytes) */
1137 Stream_Read_INT32(s, monitor->top); /* top (4 bytes) */
1138 Stream_Read_INT32(s, monitor->right); /* right (4 bytes) */
1139 Stream_Read_INT32(s, monitor->bottom); /* bottom (4 bytes) */
1140 Stream_Read_UINT32(s, monitor->flags); /* flags (4 bytes) */
1141 }
1142
1143 IFCALLRET(rdp->update->RemoteMonitors, ret, rdp->context, monitorCount, monitorDefArray);
1144 free(monitorDefArray);
1145 if (!ret)
1146 return FALSE;
1147 return rdp_set_monitor_layout_pdu_state(rdp, TRUE);
1148}
1149
1150state_run_t rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
1151{
1152 BYTE type = 0;
1153 wStream* cs = NULL;
1154 UINT16 length = 0;
1155 UINT32 shareId = 0;
1156 BYTE compressedType = 0;
1157 UINT16 compressedLength = 0;
1158
1159 WINPR_ASSERT(rdp);
1160 if (!rdp_read_share_data_header(rdp, s, &length, &type, &shareId, &compressedType,
1161 &compressedLength))
1162 {
1163 WLog_Print(rdp->log, WLOG_ERROR, "rdp_read_share_data_header() failed");
1164 return STATE_RUN_FAILED;
1165 }
1166
1167 cs = s;
1168
1169 if (compressedType & PACKET_COMPRESSED)
1170 {
1171 if (compressedLength < 18)
1172 {
1173 WLog_Print(rdp->log, WLOG_ERROR,
1174 "bulk_decompress: not enough bytes for compressedLength %" PRIu16 "",
1175 compressedLength);
1176 return STATE_RUN_FAILED;
1177 }
1178
1179 UINT32 DstSize = 0;
1180 const BYTE* pDstData = NULL;
1181 UINT16 SrcSize = compressedLength - 18;
1182
1183 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, SrcSize))
1184 {
1185 WLog_Print(rdp->log, WLOG_ERROR,
1186 "bulk_decompress: not enough bytes for compressedLength %" PRIu16 "",
1187 compressedLength);
1188 return STATE_RUN_FAILED;
1189 }
1190
1191 if (bulk_decompress(rdp->bulk, Stream_ConstPointer(s), SrcSize, &pDstData, &DstSize,
1192 compressedType))
1193 {
1194 cs = transport_take_from_pool(rdp->transport, DstSize);
1195 if (!cs)
1196 {
1197 WLog_Print(rdp->log, WLOG_ERROR, "Couldn't take stream from pool");
1198 return STATE_RUN_FAILED;
1199 }
1200
1201 Stream_SetPosition(cs, 0);
1202 Stream_Write(cs, pDstData, DstSize);
1203 Stream_SealLength(cs);
1204 Stream_SetPosition(cs, 0);
1205 }
1206 else
1207 {
1208 WLog_Print(rdp->log, WLOG_ERROR, "bulk_decompress() failed");
1209 return STATE_RUN_FAILED;
1210 }
1211
1212 Stream_Seek(s, SrcSize);
1213 }
1214
1215 WLog_Print(rdp->log, WLOG_DEBUG, "recv %s Data PDU (0x%02" PRIX8 "), length: %" PRIu16 "",
1216 data_pdu_type_to_string(type), type, length);
1217
1218 switch (type)
1219 {
1220 case DATA_PDU_TYPE_UPDATE:
1221 if (!update_recv(rdp->update, cs))
1222 {
1223 WLog_Print(rdp->log, WLOG_ERROR, "DATA_PDU_TYPE_UPDATE - update_recv() failed");
1224 goto out_fail;
1225 }
1226
1227 break;
1228
1229 case DATA_PDU_TYPE_CONTROL:
1230 if (!rdp_recv_server_control_pdu(rdp, cs))
1231 {
1232 WLog_Print(rdp->log, WLOG_ERROR,
1233 "DATA_PDU_TYPE_CONTROL - rdp_recv_server_control_pdu() failed");
1234 goto out_fail;
1235 }
1236
1237 break;
1238
1239 case DATA_PDU_TYPE_POINTER:
1240 if (!update_recv_pointer(rdp->update, cs))
1241 {
1242 WLog_Print(rdp->log, WLOG_ERROR,
1243 "DATA_PDU_TYPE_POINTER - update_recv_pointer() failed");
1244 goto out_fail;
1245 }
1246
1247 break;
1248
1249 case DATA_PDU_TYPE_SYNCHRONIZE:
1250 if (!rdp_recv_server_synchronize_pdu(rdp, cs))
1251 {
1252 WLog_Print(rdp->log, WLOG_ERROR,
1253 "DATA_PDU_TYPE_SYNCHRONIZE - rdp_recv_synchronize_pdu() failed");
1254 goto out_fail;
1255 }
1256
1257 break;
1258
1259 case DATA_PDU_TYPE_PLAY_SOUND:
1260 if (!update_recv_play_sound(rdp->update, cs))
1261 {
1262 WLog_Print(rdp->log, WLOG_ERROR,
1263 "DATA_PDU_TYPE_PLAY_SOUND - update_recv_play_sound() failed");
1264 goto out_fail;
1265 }
1266
1267 break;
1268
1269 case DATA_PDU_TYPE_SHUTDOWN_DENIED:
1270 if (!rdp_recv_server_shutdown_denied_pdu(rdp, cs))
1271 {
1272 WLog_Print(
1273 rdp->log, WLOG_ERROR,
1274 "DATA_PDU_TYPE_SHUTDOWN_DENIED - rdp_recv_server_shutdown_denied_pdu() failed");
1275 goto out_fail;
1276 }
1277
1278 break;
1279
1280 case DATA_PDU_TYPE_SAVE_SESSION_INFO:
1281 if (!rdp_recv_save_session_info(rdp, cs))
1282 {
1283 WLog_Print(rdp->log, WLOG_ERROR,
1284 "DATA_PDU_TYPE_SAVE_SESSION_INFO - rdp_recv_save_session_info() failed");
1285 goto out_fail;
1286 }
1287
1288 break;
1289
1290 case DATA_PDU_TYPE_FONT_MAP:
1291 if (!rdp_recv_font_map_pdu(rdp, cs))
1292 {
1293 WLog_Print(rdp->log, WLOG_ERROR,
1294 "DATA_PDU_TYPE_FONT_MAP - rdp_recv_font_map_pdu() failed");
1295 goto out_fail;
1296 }
1297
1298 break;
1299
1300 case DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS:
1301 if (!rdp_recv_server_set_keyboard_indicators_pdu(rdp, cs))
1302 {
1303 WLog_Print(rdp->log, WLOG_ERROR,
1304 "DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS - "
1305 "rdp_recv_server_set_keyboard_indicators_pdu() failed");
1306 goto out_fail;
1307 }
1308
1309 break;
1310
1311 case DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS:
1312 if (!rdp_recv_server_set_keyboard_ime_status_pdu(rdp, cs))
1313 {
1314 WLog_Print(rdp->log, WLOG_ERROR,
1315 "DATA_PDU_TYPE_SET_KEYBOARD_IME_STATUS - "
1316 "rdp_recv_server_set_keyboard_ime_status_pdu() failed");
1317 goto out_fail;
1318 }
1319
1320 break;
1321
1322 case DATA_PDU_TYPE_SET_ERROR_INFO:
1323 if (!rdp_recv_set_error_info_data_pdu(rdp, cs))
1324 {
1325 WLog_Print(
1326 rdp->log, WLOG_ERROR,
1327 "DATA_PDU_TYPE_SET_ERROR_INFO - rdp_recv_set_error_info_data_pdu() failed");
1328 goto out_fail;
1329 }
1330
1331 break;
1332
1333 case DATA_PDU_TYPE_ARC_STATUS:
1334 if (!rdp_recv_server_auto_reconnect_status_pdu(rdp, cs))
1335 {
1336 WLog_Print(rdp->log, WLOG_ERROR,
1337 "DATA_PDU_TYPE_ARC_STATUS - "
1338 "rdp_recv_server_auto_reconnect_status_pdu() failed");
1339 goto out_fail;
1340 }
1341
1342 break;
1343
1344 case DATA_PDU_TYPE_STATUS_INFO:
1345 if (!rdp_recv_server_status_info_pdu(rdp, cs))
1346 {
1347 WLog_Print(rdp->log, WLOG_ERROR,
1348 "DATA_PDU_TYPE_STATUS_INFO - rdp_recv_server_status_info_pdu() failed");
1349 goto out_fail;
1350 }
1351
1352 break;
1353
1354 case DATA_PDU_TYPE_MONITOR_LAYOUT:
1355 if (!rdp_recv_monitor_layout_pdu(rdp, cs))
1356 {
1357 WLog_Print(rdp->log, WLOG_ERROR,
1358 "DATA_PDU_TYPE_MONITOR_LAYOUT - rdp_recv_monitor_layout_pdu() failed");
1359 goto out_fail;
1360 }
1361
1362 break;
1363
1364 default:
1365 WLog_Print(rdp->log, WLOG_WARN,
1366 "[UNHANDLED] %s Data PDU (0x%02" PRIX8 "), length: %" PRIu16 "",
1367 data_pdu_type_to_string(type), type, length);
1368 break;
1369 }
1370
1371 if (cs != s)
1372 Stream_Release(cs);
1373
1374 return STATE_RUN_SUCCESS;
1375out_fail:
1376
1377 if (cs != s)
1378 Stream_Release(cs);
1379
1380 return STATE_RUN_FAILED;
1381}
1382
1383state_run_t rdp_recv_message_channel_pdu(rdpRdp* rdp, wStream* s, UINT16 securityFlags)
1384{
1385 WINPR_ASSERT(rdp);
1386 WINPR_ASSERT(s);
1387
1388 if (securityFlags & SEC_AUTODETECT_REQ)
1389 {
1390 /* Server Auto-Detect Request PDU */
1391 return autodetect_recv_request_packet(rdp->autodetect, RDP_TRANSPORT_TCP, s);
1392 }
1393
1394 if (securityFlags & SEC_AUTODETECT_RSP)
1395 {
1396 /* Client Auto-Detect Response PDU */
1397 return autodetect_recv_response_packet(rdp->autodetect, RDP_TRANSPORT_TCP, s);
1398 }
1399
1400 if (securityFlags & SEC_HEARTBEAT)
1401 {
1402 /* Heartbeat PDU */
1403 return rdp_recv_heartbeat_packet(rdp, s);
1404 }
1405
1406 if (securityFlags & SEC_TRANSPORT_REQ)
1407 {
1408 return multitransport_recv_request(rdp->multitransport, s);
1409 }
1410
1411 if (securityFlags & SEC_TRANSPORT_RSP)
1412 {
1413 return multitransport_recv_response(rdp->multitransport, s);
1414 }
1415
1416 if (securityFlags & SEC_LICENSE_PKT)
1417 {
1418 return license_recv(rdp->license, s);
1419 }
1420
1421 if (securityFlags & SEC_LICENSE_ENCRYPT_CS)
1422 {
1423 return license_recv(rdp->license, s);
1424 }
1425
1426 if (securityFlags & SEC_LICENSE_ENCRYPT_SC)
1427 {
1428 return license_recv(rdp->license, s);
1429 }
1430
1431 return STATE_RUN_SUCCESS;
1432}
1433
1434state_run_t rdp_recv_out_of_sequence_pdu(rdpRdp* rdp, wStream* s, UINT16 pduType, UINT16 length)
1435{
1436 state_run_t rc = STATE_RUN_FAILED;
1437 WINPR_ASSERT(rdp);
1438
1439 switch (pduType)
1440 {
1441 case PDU_TYPE_DATA:
1442 rc = rdp_recv_data_pdu(rdp, s);
1443 break;
1444 case PDU_TYPE_SERVER_REDIRECTION:
1445 rc = rdp_recv_enhanced_security_redirection_packet(rdp, s);
1446 break;
1447 case PDU_TYPE_FLOW_RESPONSE:
1448 case PDU_TYPE_FLOW_STOP:
1449 case PDU_TYPE_FLOW_TEST:
1450 rc = STATE_RUN_SUCCESS;
1451 break;
1452 default:
1453 {
1454 char buffer1[256] = { 0 };
1455 char buffer2[256] = { 0 };
1456
1457 WLog_Print(rdp->log, WLOG_ERROR, "expected %s, got %s",
1458 pdu_type_to_str(PDU_TYPE_DEMAND_ACTIVE, buffer1, sizeof(buffer1)),
1459 pdu_type_to_str(pduType, buffer2, sizeof(buffer2)));
1460 rc = STATE_RUN_FAILED;
1461 }
1462 break;
1463 }
1464
1465 if (!tpkt_ensure_stream_consumed(rdp->log, s, length))
1466 return STATE_RUN_FAILED;
1467 return rc;
1468}
1469
1470BOOL rdp_read_flow_control_pdu(rdpRdp* rdp, wStream* s, UINT16* type, UINT16* channel_id)
1471{
1472 /*
1473 * Read flow control PDU - documented in FlowPDU section in T.128
1474 * http://www.itu.int/rec/T-REC-T.128-199802-S/en
1475 * The specification for the PDU has pad8bits listed BEFORE pduTypeFlow.
1476 * However, so far pad8bits has always been observed to arrive AFTER pduTypeFlow.
1477 * Switched the order of these two fields to match this observation.
1478 */
1479 UINT8 pduType = 0;
1480
1481 WINPR_ASSERT(rdp);
1482 WINPR_ASSERT(s);
1483 WINPR_ASSERT(type);
1484 WINPR_ASSERT(channel_id);
1485
1486 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 6))
1487 return FALSE;
1488 Stream_Read_UINT8(s, pduType); /* pduTypeFlow */
1489 *type = pduType;
1490 Stream_Seek_UINT8(s); /* pad8bits */
1491 Stream_Seek_UINT8(s); /* flowIdentifier */
1492 Stream_Seek_UINT8(s); /* flowNumber */
1493 Stream_Read_UINT16(s, *channel_id); /* pduSource */
1494 return TRUE;
1495}
1496
1508BOOL rdp_decrypt(rdpRdp* rdp, wStream* s, UINT16* pLength, UINT16 securityFlags)
1509{
1510 BOOL res = FALSE;
1511 BYTE cmac[8] = { 0 };
1512 BYTE wmac[8] = { 0 };
1513 BOOL status = FALSE;
1514
1515 WINPR_ASSERT(rdp);
1516 WINPR_ASSERT(rdp->settings);
1517 WINPR_ASSERT(s);
1518 WINPR_ASSERT(pLength);
1519
1520 if (!security_lock(rdp))
1521 return FALSE;
1522
1523 INT32 length = *pLength;
1524 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_NONE)
1525 return TRUE;
1526
1527 if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
1528 {
1529 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, 12))
1530 goto unlock;
1531
1532 UINT16 len = 0;
1533 Stream_Read_UINT16(s, len); /* 0x10 */
1534 if (len != 0x10)
1535 WLog_Print(rdp->log, WLOG_WARN, "ENCRYPTION_METHOD_FIPS length %" PRIu16 " != 0x10",
1536 len);
1537
1538 UINT16 version = 0;
1539 Stream_Read_UINT8(s, version); /* 0x1 */
1540 if (version != 1)
1541 WLog_Print(rdp->log, WLOG_WARN, "ENCRYPTION_METHOD_FIPS version %" PRIu16 " != 1",
1542 version);
1543
1544 BYTE pad = 0;
1545 Stream_Read_UINT8(s, pad);
1546 const BYTE* sig = Stream_ConstPointer(s);
1547 Stream_Seek(s, 8); /* signature */
1548 length -= 12;
1549 const INT32 padLength = length - pad;
1550
1551 if ((length <= 0) || (padLength <= 0) || (padLength > UINT16_MAX))
1552 {
1553 WLog_Print(rdp->log, WLOG_ERROR, "FATAL: invalid pad length %" PRId32, padLength);
1554 goto unlock;
1555 }
1556
1557 if (!security_fips_decrypt(Stream_Pointer(s), (size_t)length, rdp))
1558 goto unlock;
1559
1560 if (!security_fips_check_signature(Stream_ConstPointer(s), (size_t)padLength, sig, 8, rdp))
1561 goto unlock;
1562
1563 Stream_SetLength(s, Stream_Length(s) - pad);
1564 *pLength = (UINT16)padLength;
1565 }
1566 else
1567 {
1568 if (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, sizeof(wmac)))
1569 goto unlock;
1570
1571 Stream_Read(s, wmac, sizeof(wmac));
1572 length -= sizeof(wmac);
1573
1574 if (length <= 0)
1575 {
1576 WLog_Print(rdp->log, WLOG_ERROR, "FATAL: invalid length field");
1577 goto unlock;
1578 }
1579
1580 if (!security_decrypt(Stream_PointerAs(s, BYTE), (size_t)length, rdp))
1581 goto unlock;
1582
1583 if (securityFlags & SEC_SECURE_CHECKSUM)
1584 status = security_salted_mac_signature(rdp, Stream_ConstPointer(s), (UINT32)length,
1585 FALSE, cmac, sizeof(cmac));
1586 else
1587 status = security_mac_signature(rdp, Stream_ConstPointer(s), (UINT32)length, cmac,
1588 sizeof(cmac));
1589
1590 if (!status)
1591 goto unlock;
1592
1593 if (memcmp(wmac, cmac, sizeof(wmac)) != 0)
1594 {
1595 WLog_Print(rdp->log, WLOG_ERROR, "WARNING: invalid packet signature");
1596 /*
1597 * Because Standard RDP Security is totally broken,
1598 * and cannot protect against MITM, don't treat signature
1599 * verification failure as critical. This at least enables
1600 * us to work with broken RDP clients and servers that
1601 * generate invalid signatures.
1602 */
1603 // return FALSE;
1604 }
1605
1606 *pLength = (UINT16)length;
1607 }
1608 res = TRUE;
1609unlock:
1610 if (!security_unlock(rdp))
1611 return FALSE;
1612 return res;
1613}
1614
1615const char* pdu_type_to_str(UINT16 pduType, char* buffer, size_t length)
1616{
1617 const char* str = NULL;
1618 switch (pduType)
1619 {
1620 case PDU_TYPE_DEMAND_ACTIVE:
1621 str = "PDU_TYPE_DEMAND_ACTIVE";
1622 break;
1623 case PDU_TYPE_CONFIRM_ACTIVE:
1624 str = "PDU_TYPE_CONFIRM_ACTIVE";
1625 break;
1626 case PDU_TYPE_DEACTIVATE_ALL:
1627 str = "PDU_TYPE_DEACTIVATE_ALL";
1628 break;
1629 case PDU_TYPE_DATA:
1630 str = "PDU_TYPE_DATA";
1631 break;
1632 case PDU_TYPE_SERVER_REDIRECTION:
1633 str = "PDU_TYPE_SERVER_REDIRECTION";
1634 break;
1635 case PDU_TYPE_FLOW_TEST:
1636 str = "PDU_TYPE_FLOW_TEST";
1637 break;
1638 case PDU_TYPE_FLOW_RESPONSE:
1639 str = "PDU_TYPE_FLOW_RESPONSE";
1640 break;
1641 case PDU_TYPE_FLOW_STOP:
1642 str = "PDU_TYPE_FLOW_STOP";
1643 break;
1644 default:
1645 str = "PDU_TYPE_UNKNOWN";
1646 break;
1647 }
1648
1649 winpr_str_append(str, buffer, length, "");
1650 {
1651 char msg[32] = { 0 };
1652 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", pduType);
1653 winpr_str_append(msg, buffer, length, "");
1654 }
1655 return buffer;
1656}
1657
1664static state_run_t rdp_recv_tpkt_pdu(rdpRdp* rdp, wStream* s)
1665{
1666 state_run_t rc = STATE_RUN_SUCCESS;
1667 UINT16 length = 0;
1668 UINT16 pduType = 0;
1669 UINT16 pduSource = 0;
1670 UINT16 channelId = 0;
1671 UINT16 securityFlags = 0;
1672
1673 WINPR_ASSERT(rdp);
1674 WINPR_ASSERT(rdp->context);
1675 WINPR_ASSERT(s);
1676
1677 freerdp* instance = rdp->context->instance;
1678 WINPR_ASSERT(instance);
1679
1680 if (!rdp_read_header(rdp, s, &length, &channelId))
1681 return STATE_RUN_FAILED;
1682
1683 if (freerdp_shall_disconnect_context(rdp->context))
1684 return STATE_RUN_SUCCESS;
1685
1686 if (rdp->autodetect->bandwidthMeasureStarted)
1687 {
1688 rdp->autodetect->bandwidthMeasureByteCount += length;
1689 }
1690
1691 if (rdp->mcs->messageChannelId && (channelId == rdp->mcs->messageChannelId))
1692 {
1693 rdp->inPackets++;
1694 return rdp_handle_message_channel(rdp, s, channelId, length);
1695 }
1696
1697 if (rdp->settings->UseRdpSecurityLayer)
1698 {
1699 if (!rdp_read_security_header(rdp, s, &securityFlags, &length))
1700 return STATE_RUN_FAILED;
1701
1702 if (securityFlags & (SEC_ENCRYPT | SEC_REDIRECTION_PKT))
1703 {
1704 if (!rdp_decrypt(rdp, s, &length, securityFlags))
1705 return STATE_RUN_FAILED;
1706 }
1707
1708 if (securityFlags & SEC_REDIRECTION_PKT)
1709 {
1710 /*
1711 * [MS-RDPBCGR] 2.2.13.2.1
1712 * - no share control header, nor the 2 byte pad
1713 */
1714 Stream_Rewind(s, 2);
1715 rdp->inPackets++;
1716
1717 rc = rdp_recv_enhanced_security_redirection_packet(rdp, s);
1718 goto out;
1719 }
1720 }
1721
1722 if (channelId == MCS_GLOBAL_CHANNEL_ID)
1723 {
1724 while (Stream_GetRemainingLength(s) > 3)
1725 {
1726 wStream subbuffer;
1727 wStream* sub = NULL;
1728 size_t diff = 0;
1729 UINT16 remain = 0;
1730
1731 if (!rdp_read_share_control_header(rdp, s, NULL, &remain, &pduType, &pduSource))
1732 return STATE_RUN_FAILED;
1733
1734 sub = Stream_StaticInit(&subbuffer, Stream_Pointer(s), remain);
1735 if (!Stream_SafeSeek(s, remain))
1736 return STATE_RUN_FAILED;
1737
1738 rdp->settings->PduSource = pduSource;
1739 rdp->inPackets++;
1740
1741 switch (pduType)
1742 {
1743 case PDU_TYPE_DATA:
1744 rc = rdp_recv_data_pdu(rdp, sub);
1745 if (state_run_failed(rc))
1746 return rc;
1747 break;
1748
1749 case PDU_TYPE_DEACTIVATE_ALL:
1750 if (!rdp_recv_deactivate_all(rdp, sub))
1751 {
1752 WLog_Print(rdp->log, WLOG_ERROR,
1753 "rdp_recv_tpkt_pdu: rdp_recv_deactivate_all() fail");
1754 return STATE_RUN_FAILED;
1755 }
1756
1757 break;
1758
1759 case PDU_TYPE_SERVER_REDIRECTION:
1760 return rdp_recv_enhanced_security_redirection_packet(rdp, sub);
1761
1762 case PDU_TYPE_FLOW_RESPONSE:
1763 case PDU_TYPE_FLOW_STOP:
1764 case PDU_TYPE_FLOW_TEST:
1765 WLog_Print(rdp->log, WLOG_DEBUG, "flow message 0x%04" PRIX16 "", pduType);
1766 /* http://msdn.microsoft.com/en-us/library/cc240576.aspx */
1767 if (!Stream_SafeSeek(sub, remain))
1768 return STATE_RUN_FAILED;
1769 break;
1770
1771 default:
1772 {
1773 char buffer[256] = { 0 };
1774 WLog_Print(rdp->log, WLOG_ERROR, "incorrect PDU type: %s",
1775 pdu_type_to_str(pduType, buffer, sizeof(buffer)));
1776 }
1777 break;
1778 }
1779
1780 diff = Stream_GetRemainingLength(sub);
1781 if (diff > 0)
1782 {
1783 char buffer[256] = { 0 };
1784 WLog_Print(rdp->log, WLOG_WARN,
1785 "pduType %s not properly parsed, %" PRIuz
1786 " bytes remaining unhandled. Skipping.",
1787 pdu_type_to_str(pduType, buffer, sizeof(buffer)), diff);
1788 }
1789 }
1790 }
1791 else
1792 {
1793 rdp->inPackets++;
1794
1795 if (!freerdp_channel_process(instance, s, channelId, length))
1796 return STATE_RUN_FAILED;
1797 }
1798
1799out:
1800 if (!tpkt_ensure_stream_consumed(rdp->log, s, length))
1801 return STATE_RUN_FAILED;
1802 return rc;
1803}
1804
1805static state_run_t rdp_recv_fastpath_pdu(rdpRdp* rdp, wStream* s)
1806{
1807 UINT16 length = 0;
1808
1809 WINPR_ASSERT(rdp);
1810 rdpFastPath* fastpath = rdp->fastpath;
1811
1812 if (!fastpath_read_header_rdp(fastpath, s, &length))
1813 {
1814 WLog_Print(rdp->log, WLOG_ERROR, "rdp_recv_fastpath_pdu: fastpath_read_header_rdp() fail");
1815 return STATE_RUN_FAILED;
1816 }
1817
1818 if ((length == 0) || (!Stream_CheckAndLogRequiredLengthWLog(rdp->log, s, length)))
1819 {
1820 WLog_Print(rdp->log, WLOG_ERROR, "incorrect FastPath PDU header length %" PRIu16 "",
1821 length);
1822 return STATE_RUN_FAILED;
1823 }
1824
1825 if (rdp->autodetect->bandwidthMeasureStarted)
1826 {
1827 rdp->autodetect->bandwidthMeasureByteCount += length;
1828 }
1829
1830 if (!fastpath_decrypt(fastpath, s, &length))
1831 return STATE_RUN_FAILED;
1832
1833 return fastpath_recv_updates(rdp->fastpath, s);
1834}
1835
1836static state_run_t rdp_recv_pdu(rdpRdp* rdp, wStream* s)
1837{
1838 const int rc = tpkt_verify_header(s);
1839 if (rc > 0)
1840 return rdp_recv_tpkt_pdu(rdp, s);
1841 else if (rc == 0)
1842 return rdp_recv_fastpath_pdu(rdp, s);
1843 else
1844 return STATE_RUN_FAILED;
1845}
1846
1847static state_run_t rdp_handle_sc_flags(rdpRdp* rdp, wStream* s, UINT32 flag,
1848 CONNECTION_STATE nextState)
1849{
1850 const UINT32 mask = FINALIZE_SC_SYNCHRONIZE_PDU | FINALIZE_SC_CONTROL_COOPERATE_PDU |
1851 FINALIZE_SC_CONTROL_GRANTED_PDU | FINALIZE_SC_FONT_MAP_PDU;
1852 WINPR_ASSERT(rdp);
1853 state_run_t status = rdp_recv_pdu(rdp, s);
1854 if (state_run_success(status))
1855 {
1856 const UINT32 flags = rdp->finalize_sc_pdus & mask;
1857 if ((flags & flag) == flag)
1858 {
1859 if (!rdp_client_transition_to_state(rdp, nextState))
1860 status = STATE_RUN_FAILED;
1861 else
1862 status = STATE_RUN_SUCCESS;
1863 }
1864 else
1865 {
1866 char flag_buffer[256] = { 0 };
1867 char mask_buffer[256] = { 0 };
1868 WLog_Print(rdp->log, WLOG_WARN,
1869 "[%s] unexpected server message, expected flag %s [have %s]",
1870 rdp_get_state_string(rdp),
1871 rdp_finalize_flags_to_str(flag, flag_buffer, sizeof(flag_buffer)),
1872 rdp_finalize_flags_to_str(flags, mask_buffer, sizeof(mask_buffer)));
1873 }
1874 }
1875 return status;
1876}
1877
1878static state_run_t rdp_client_exchange_monitor_layout(rdpRdp* rdp, wStream* s)
1879{
1880 WINPR_ASSERT(rdp);
1881
1882 if (!rdp_check_monitor_layout_pdu_state(rdp, FALSE))
1883 return STATE_RUN_FAILED;
1884
1885 /* We might receive unrelated messages from the server (channel traffic),
1886 * so only proceed if some flag changed
1887 */
1888 const UINT32 old = rdp->finalize_sc_pdus;
1889 state_run_t status = rdp_recv_pdu(rdp, s);
1890 const UINT32 now = rdp->finalize_sc_pdus;
1891 const BOOL changed = (old != now) || rdp->monitor_layout_pdu;
1892
1893 /* This PDU is optional, so if we received a finalize PDU continue there */
1894 if (state_run_success(status) && changed)
1895 {
1896 if (!rdp->monitor_layout_pdu)
1897 {
1898 if (!rdp_finalize_is_flag_set(rdp, FINALIZE_SC_SYNCHRONIZE_PDU))
1899 return STATE_RUN_FAILED;
1900 }
1901
1902 status = rdp_client_connect_finalize(rdp);
1903 if (state_run_success(status) && !rdp->monitor_layout_pdu)
1904 status = STATE_RUN_TRY_AGAIN;
1905 }
1906 return status;
1907}
1908
1909static state_run_t rdp_recv_callback_int(WINPR_ATTR_UNUSED rdpTransport* transport, wStream* s,
1910 void* extra)
1911{
1912 state_run_t status = STATE_RUN_SUCCESS;
1913 rdpRdp* rdp = (rdpRdp*)extra;
1914
1915 WINPR_ASSERT(transport);
1916 WINPR_ASSERT(rdp);
1917 WINPR_ASSERT(s);
1918
1919 switch (rdp_get_state(rdp))
1920 {
1921 case CONNECTION_STATE_NEGO:
1922 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
1923 status = STATE_RUN_FAILED;
1924 else
1925 status = STATE_RUN_CONTINUE;
1926 break;
1927 case CONNECTION_STATE_NLA:
1928 if (nla_get_state(rdp->nla) < NLA_STATE_AUTH_INFO)
1929 {
1930 if (nla_recv_pdu(rdp->nla, s) < 1)
1931 {
1932 WLog_Print(rdp->log, WLOG_ERROR, "%s - nla_recv_pdu() fail",
1933 rdp_get_state_string(rdp));
1934 status = STATE_RUN_FAILED;
1935 }
1936 }
1937 else if (nla_get_state(rdp->nla) == NLA_STATE_POST_NEGO)
1938 {
1939 nego_recv(rdp->transport, s, (void*)rdp->nego);
1940
1941 if (!nego_update_settings_from_state(rdp->nego, rdp->settings))
1942 return STATE_RUN_FAILED;
1943
1944 if (nego_get_state(rdp->nego) != NEGO_STATE_FINAL)
1945 {
1946 WLog_Print(rdp->log, WLOG_ERROR, "%s - nego_recv() fail",
1947 rdp_get_state_string(rdp));
1948 status = STATE_RUN_FAILED;
1949 }
1950 else if (!nla_set_state(rdp->nla, NLA_STATE_FINAL))
1951 status = STATE_RUN_FAILED;
1952 }
1953
1954 if (state_run_success(status))
1955 {
1956 if (nla_get_state(rdp->nla) == NLA_STATE_AUTH_INFO)
1957 {
1958 transport_set_nla_mode(rdp->transport, FALSE);
1959
1960 if (rdp->settings->VmConnectMode)
1961 {
1962 if (!nego_set_state(rdp->nego, NEGO_STATE_NLA))
1963 status = STATE_RUN_FAILED;
1964 else if (!nego_set_requested_protocols(rdp->nego,
1965 PROTOCOL_HYBRID | PROTOCOL_SSL))
1966 status = STATE_RUN_FAILED;
1967 else if (!nego_send_negotiation_request(rdp->nego))
1968 status = STATE_RUN_FAILED;
1969 else if (!nla_set_state(rdp->nla, NLA_STATE_POST_NEGO))
1970 status = STATE_RUN_FAILED;
1971 }
1972 else
1973 {
1974 if (!nla_set_state(rdp->nla, NLA_STATE_FINAL))
1975 status = STATE_RUN_FAILED;
1976 }
1977 }
1978 }
1979 if (state_run_success(status))
1980 {
1981
1982 if (nla_get_state(rdp->nla) == NLA_STATE_FINAL)
1983 {
1984 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
1985 status = STATE_RUN_FAILED;
1986 else
1987 status = STATE_RUN_CONTINUE;
1988 }
1989 }
1990 break;
1991
1992 case CONNECTION_STATE_AAD:
1993 if (aad_recv(rdp->aad, s) < 1)
1994 {
1995 WLog_Print(rdp->log, WLOG_ERROR, "%s - aad_recv() fail", rdp_get_state_string(rdp));
1996 status = STATE_RUN_FAILED;
1997 }
1998 if (state_run_success(status))
1999 {
2000 if (aad_get_state(rdp->aad) == AAD_STATE_FINAL)
2001 {
2002 transport_set_aad_mode(rdp->transport, FALSE);
2003 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
2004 status = STATE_RUN_FAILED;
2005 else
2006 status = STATE_RUN_CONTINUE;
2007 }
2008 }
2009 break;
2010
2011 case CONNECTION_STATE_MCS_CREATE_REQUEST:
2012 if (!mcs_client_begin(rdp->mcs))
2013 {
2014 WLog_Print(rdp->log, WLOG_ERROR, "%s - mcs_client_begin() fail",
2015 rdp_get_state_string(rdp));
2016 status = STATE_RUN_FAILED;
2017 }
2018 else if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_RESPONSE))
2019 status = STATE_RUN_FAILED;
2020 else if (Stream_GetRemainingLength(s) > 0)
2021 status = STATE_RUN_CONTINUE;
2022 break;
2023
2024 case CONNECTION_STATE_MCS_CREATE_RESPONSE:
2025 if (!mcs_recv_connect_response(rdp->mcs, s))
2026 {
2027 WLog_Print(rdp->log, WLOG_ERROR, "mcs_recv_connect_response failure");
2028 status = STATE_RUN_FAILED;
2029 }
2030 else
2031 {
2032 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_ERECT_DOMAIN))
2033 status = STATE_RUN_FAILED;
2034 else if (!mcs_send_erect_domain_request(rdp->mcs))
2035 {
2036 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_erect_domain_request failure");
2037 status = STATE_RUN_FAILED;
2038 }
2039 else if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_ATTACH_USER))
2040 status = STATE_RUN_FAILED;
2041 else if (!mcs_send_attach_user_request(rdp->mcs))
2042 {
2043 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_attach_user_request failure");
2044 status = STATE_RUN_FAILED;
2045 }
2046 else if (!rdp_client_transition_to_state(rdp,
2047 CONNECTION_STATE_MCS_ATTACH_USER_CONFIRM))
2048 status = STATE_RUN_FAILED;
2049 }
2050 break;
2051
2052 case CONNECTION_STATE_MCS_ATTACH_USER_CONFIRM:
2053 if (!mcs_recv_attach_user_confirm(rdp->mcs, s))
2054 {
2055 WLog_Print(rdp->log, WLOG_ERROR, "mcs_recv_attach_user_confirm failure");
2056 status = STATE_RUN_FAILED;
2057 }
2058 else if (!freerdp_settings_get_bool(rdp->settings, FreeRDP_SupportSkipChannelJoin))
2059 {
2060 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_MCS_CHANNEL_JOIN_REQUEST))
2061 status = STATE_RUN_FAILED;
2062 else if (!mcs_send_channel_join_request(rdp->mcs, rdp->mcs->userId))
2063 {
2064 WLog_Print(rdp->log, WLOG_ERROR, "mcs_send_channel_join_request failure");
2065 status = STATE_RUN_FAILED;
2066 }
2067 else if (!rdp_client_transition_to_state(
2068 rdp, CONNECTION_STATE_MCS_CHANNEL_JOIN_RESPONSE))
2069 status = STATE_RUN_FAILED;
2070 }
2071 else
2072 {
2073 /* SKIP_CHANNELJOIN is active, consider channels to be joined */
2074 if (!rdp_client_skip_mcs_channel_join(rdp))
2075 status = STATE_RUN_FAILED;
2076 }
2077 break;
2078
2079 case CONNECTION_STATE_MCS_CHANNEL_JOIN_RESPONSE:
2080 if (!rdp_client_connect_mcs_channel_join_confirm(rdp, s))
2081 {
2082 WLog_Print(rdp->log, WLOG_ERROR,
2083 "%s - "
2084 "rdp_client_connect_mcs_channel_join_confirm() fail",
2085 rdp_get_state_string(rdp));
2086 status = STATE_RUN_FAILED;
2087 }
2088
2089 break;
2090
2091 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_REQUEST:
2092 if (!rdp_client_connect_auto_detect(rdp, s, WLOG_DEBUG))
2093 {
2094 if (!rdp_client_transition_to_state(rdp, CONNECTION_STATE_LICENSING))
2095 status = STATE_RUN_FAILED;
2096 else
2097 status = STATE_RUN_TRY_AGAIN;
2098 }
2099 break;
2100
2101 case CONNECTION_STATE_LICENSING:
2102 status = rdp_client_connect_license(rdp, s);
2103
2104 if (state_run_failed(status))
2105 {
2106 char buffer[64] = { 0 };
2107 WLog_Print(rdp->log, WLOG_DEBUG, "%s - rdp_client_connect_license() - %s",
2108 rdp_get_state_string(rdp),
2109 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2110 }
2111
2112 break;
2113
2114 case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_REQUEST:
2115 if (!rdp_client_connect_auto_detect(rdp, s, WLOG_DEBUG))
2116 {
2117 (void)rdp_client_transition_to_state(
2118 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
2119 status = STATE_RUN_TRY_AGAIN;
2120 }
2121 break;
2122
2123 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE:
2124 status = rdp_client_connect_demand_active(rdp, s);
2125
2126 if (state_run_failed(status))
2127 {
2128 char buffer[64] = { 0 };
2129 WLog_Print(rdp->log, WLOG_DEBUG,
2130 "%s - "
2131 "rdp_client_connect_demand_active() - %s",
2132 rdp_get_state_string(rdp),
2133 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2134 }
2135 else if (status == STATE_RUN_ACTIVE)
2136 {
2137 if (!rdp_client_transition_to_state(
2138 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE))
2139 status = STATE_RUN_FAILED;
2140 else
2141 status = STATE_RUN_CONTINUE;
2142 }
2143 break;
2144
2145 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_MONITOR_LAYOUT:
2146 status = rdp_client_exchange_monitor_layout(rdp, s);
2147 break;
2148
2149 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE:
2150 status = rdp_client_connect_confirm_active(rdp, s);
2151 break;
2152
2153 case CONNECTION_STATE_FINALIZATION_CLIENT_SYNC:
2154 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_SYNCHRONIZE_PDU,
2155 CONNECTION_STATE_FINALIZATION_CLIENT_COOPERATE);
2156 break;
2157 case CONNECTION_STATE_FINALIZATION_CLIENT_COOPERATE:
2158 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_CONTROL_COOPERATE_PDU,
2159 CONNECTION_STATE_FINALIZATION_CLIENT_GRANTED_CONTROL);
2160 break;
2161 case CONNECTION_STATE_FINALIZATION_CLIENT_GRANTED_CONTROL:
2162 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_CONTROL_GRANTED_PDU,
2163 CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP);
2164 break;
2165 case CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP:
2166 status = rdp_handle_sc_flags(rdp, s, FINALIZE_SC_FONT_MAP_PDU, CONNECTION_STATE_ACTIVE);
2167 break;
2168
2169 case CONNECTION_STATE_ACTIVE:
2170 status = rdp_recv_pdu(rdp, s);
2171
2172 if (state_run_failed(status))
2173 {
2174 char buffer[64] = { 0 };
2175 WLog_Print(rdp->log, WLOG_DEBUG, "%s - rdp_recv_pdu() - %s",
2176 rdp_get_state_string(rdp),
2177 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2178 }
2179 break;
2180
2181 default:
2182 WLog_Print(rdp->log, WLOG_ERROR, "%s state %u", rdp_get_state_string(rdp),
2183 rdp_get_state(rdp));
2184 status = STATE_RUN_FAILED;
2185 break;
2186 }
2187
2188 if (state_run_failed(status))
2189 {
2190 char buffer[64] = { 0 };
2191 WLog_Print(rdp->log, WLOG_ERROR, "%s status %s", rdp_get_state_string(rdp),
2192 state_run_result_string(status, buffer, ARRAYSIZE(buffer)));
2193 }
2194 return status;
2195}
2196
2197state_run_t rdp_recv_callback(rdpTransport* transport, wStream* s, void* extra)
2198{
2199 char buffer[64] = { 0 };
2200 state_run_t rc = STATE_RUN_FAILED;
2201 const size_t start = Stream_GetPosition(s);
2202 const rdpContext* context = transport_get_context(transport);
2203
2204 WINPR_ASSERT(context);
2205 do
2206 {
2207 const rdpRdp* rdp = context->rdp;
2208 WINPR_ASSERT(rdp);
2209
2210 if (rc == STATE_RUN_TRY_AGAIN)
2211 Stream_SetPosition(s, start);
2212
2213 const char* old = rdp_get_state_string(rdp);
2214 const size_t orem = Stream_GetRemainingLength(s);
2215 rc = rdp_recv_callback_int(transport, s, extra);
2216
2217 const char* now = rdp_get_state_string(rdp);
2218 const size_t rem = Stream_GetRemainingLength(s);
2219
2220 WLog_Print(rdp->log, WLOG_TRACE,
2221 "(client)[%s -> %s] current return %s [feeding %" PRIuz " bytes, %" PRIuz
2222 " bytes not processed]",
2223 old, now, state_run_result_string(rc, buffer, sizeof(buffer)), orem, rem);
2224 } while ((rc == STATE_RUN_TRY_AGAIN) || (rc == STATE_RUN_CONTINUE));
2225 return rc;
2226}
2227
2228BOOL rdp_send_channel_data(rdpRdp* rdp, UINT16 channelId, const BYTE* data, size_t size)
2229{
2230 return freerdp_channel_send(rdp, channelId, data, size);
2231}
2232
2233BOOL rdp_channel_send_packet(rdpRdp* rdp, UINT16 channelId, size_t totalSize, UINT32 flags,
2234 const BYTE* data, size_t chunkSize)
2235{
2236 return freerdp_channel_send_packet(rdp, channelId, totalSize, flags, data, chunkSize);
2237}
2238
2239BOOL rdp_send_error_info(rdpRdp* rdp)
2240{
2241 UINT16 sec_flags = 0;
2242 wStream* s = NULL;
2243 BOOL status = 0;
2244
2245 if (rdp->errorInfo == ERRINFO_SUCCESS)
2246 return TRUE;
2247
2248 s = rdp_data_pdu_init(rdp, &sec_flags);
2249
2250 if (!s)
2251 return FALSE;
2252
2253 Stream_Write_UINT32(s, rdp->errorInfo); /* error id (4 bytes) */
2254 status = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_ERROR_INFO, 0, sec_flags);
2255 return status;
2256}
2257
2258int rdp_check_fds(rdpRdp* rdp)
2259{
2260 int status = 0;
2261 rdpTsg* tsg = NULL;
2262 rdpTransport* transport = NULL;
2263
2264 WINPR_ASSERT(rdp);
2265 transport = rdp->transport;
2266
2267 tsg = transport_get_tsg(transport);
2268 if (tsg)
2269 {
2270 if (!tsg_check_event_handles(tsg))
2271 {
2272 WLog_Print(rdp->log, WLOG_ERROR, "rdp_check_fds: tsg_check_event_handles()");
2273 return -1;
2274 }
2275
2276 if (tsg_get_state(tsg) != TSG_STATE_PIPE_CREATED)
2277 return 1;
2278 }
2279
2280 status = transport_check_fds(transport);
2281
2282 if (status == 1)
2283 {
2284 if (!rdp_client_redirect(rdp)) /* session redirection */
2285 return -1;
2286 }
2287
2288 if (status < 0)
2289 WLog_Print(rdp->log, WLOG_DEBUG, "transport_check_fds() - %i", status);
2290 else
2291 status = freerdp_timer_poll(rdp->timer);
2292
2293 return status;
2294}
2295
2296BOOL freerdp_get_stats(const rdpRdp* rdp, UINT64* inBytes, UINT64* outBytes, UINT64* inPackets,
2297 UINT64* outPackets)
2298{
2299 if (!rdp)
2300 return FALSE;
2301
2302 if (inBytes)
2303 *inBytes = rdp->inBytes;
2304 if (outBytes)
2305 *outBytes = rdp->outBytes;
2306 if (inPackets)
2307 *inPackets = rdp->inPackets;
2308 if (outPackets)
2309 *outPackets = rdp->outPackets;
2310
2311 return TRUE;
2312}
2313
2314static bool rdp_new_common(rdpRdp* rdp)
2315{
2316 WINPR_ASSERT(rdp);
2317
2318 bool rc = false;
2319 rdp->transport = transport_new(rdp->context);
2320 if (!rdp->transport)
2321 goto fail;
2322
2323 if (rdp->io)
2324 {
2325 if (!transport_set_io_callbacks(rdp->transport, rdp->io))
2326 goto fail;
2327 }
2328
2329 rdp->aad = aad_new(rdp->context);
2330 if (!rdp->aad)
2331 goto fail;
2332
2333 rdp->nego = nego_new(rdp->transport);
2334 if (!rdp->nego)
2335 goto fail;
2336
2337 rdp->mcs = mcs_new(rdp->context);
2338 if (!rdp->mcs)
2339 goto fail;
2340
2341 rdp->license = license_new(rdp);
2342 if (!rdp->license)
2343 goto fail;
2344
2345 rdp->fastpath = fastpath_new(rdp);
2346 if (!rdp->fastpath)
2347 goto fail;
2348
2349 rc = true;
2350fail:
2351 return rc;
2352}
2353
2359rdpRdp* rdp_new(rdpContext* context)
2360{
2361 DWORD flags = 0;
2362 rdpRdp* rdp = (rdpRdp*)calloc(1, sizeof(rdpRdp));
2363
2364 if (!rdp)
2365 return NULL;
2366
2367 rdp->log = WLog_Get(RDP_TAG);
2368 WINPR_ASSERT(rdp->log);
2369
2370 (void)_snprintf(rdp->log_context, sizeof(rdp->log_context), "%p", (void*)context);
2371 WLog_SetContext(rdp->log, NULL, rdp->log_context);
2372
2373 InitializeCriticalSection(&rdp->critical);
2374 rdp->context = context;
2375 WINPR_ASSERT(rdp->context);
2376
2377 if (context->ServerMode)
2378 flags |= FREERDP_SETTINGS_SERVER_MODE;
2379
2380 if (!context->settings)
2381 {
2382 context->settings = rdp->settings = freerdp_settings_new(flags);
2383
2384 if (!rdp->settings)
2385 goto fail;
2386 }
2387 else
2388 rdp->settings = context->settings;
2389
2390 /* Keep a backup copy of settings for later comparisons */
2391 if (!rdp_set_backup_settings(rdp))
2392 goto fail;
2393
2394 rdp->settings->instance = context->instance;
2395
2396 context->settings = rdp->settings;
2397 if (context->instance)
2398 context->settings->instance = context->instance;
2399 else if (context->peer)
2400 {
2401 rdp->settings->instance = context->peer;
2402
2403#if defined(WITH_FREERDP_DEPRECATED)
2404 context->peer->settings = rdp->settings;
2405#endif
2406 }
2407
2408 if (!rdp_new_common(rdp))
2409 goto fail;
2410
2411 {
2412 const rdpTransportIo* io = transport_get_io_callbacks(rdp->transport);
2413 if (!io)
2414 goto fail;
2415 rdp->io = calloc(1, sizeof(rdpTransportIo));
2416 if (!rdp->io)
2417 goto fail;
2418 *rdp->io = *io;
2419 }
2420
2421 rdp->input = input_new(rdp);
2422
2423 if (!rdp->input)
2424 goto fail;
2425
2426 rdp->update = update_new(rdp);
2427
2428 if (!rdp->update)
2429 goto fail;
2430
2431 rdp->redirection = redirection_new();
2432
2433 if (!rdp->redirection)
2434 goto fail;
2435
2436 rdp->autodetect = autodetect_new(rdp->context);
2437
2438 if (!rdp->autodetect)
2439 goto fail;
2440
2441 rdp->heartbeat = heartbeat_new();
2442
2443 if (!rdp->heartbeat)
2444 goto fail;
2445
2446 rdp->multitransport = multitransport_new(rdp, INITIATE_REQUEST_PROTOCOL_UDPFECL |
2447 INITIATE_REQUEST_PROTOCOL_UDPFECR);
2448
2449 if (!rdp->multitransport)
2450 goto fail;
2451
2452 rdp->bulk = bulk_new(context);
2453
2454 if (!rdp->bulk)
2455 goto fail;
2456
2457 rdp->pubSub = PubSub_New(TRUE);
2458 if (!rdp->pubSub)
2459 goto fail;
2460
2461 rdp->abortEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2462 if (!rdp->abortEvent)
2463 goto fail;
2464
2465 rdp->timer = freerdp_timer_new(rdp);
2466 if (!rdp->timer)
2467 goto fail;
2468
2469 return rdp;
2470
2471fail:
2472 WINPR_PRAGMA_DIAG_PUSH
2473 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
2474 rdp_free(rdp);
2475 WINPR_PRAGMA_DIAG_POP
2476 return NULL;
2477}
2478
2479static void rdp_reset_free(rdpRdp* rdp)
2480{
2481 WINPR_ASSERT(rdp);
2482
2483 (void)security_lock(rdp);
2484 rdp_free_rc4_decrypt_keys(rdp);
2485 rdp_free_rc4_encrypt_keys(rdp);
2486
2487 winpr_Cipher_Free(rdp->fips_encrypt);
2488 winpr_Cipher_Free(rdp->fips_decrypt);
2489 rdp->fips_encrypt = NULL;
2490 rdp->fips_decrypt = NULL;
2491 (void)security_unlock(rdp);
2492
2493 aad_free(rdp->aad);
2494 mcs_free(rdp->mcs);
2495 nego_free(rdp->nego);
2496 license_free(rdp->license);
2497 transport_free(rdp->transport);
2498 fastpath_free(rdp->fastpath);
2499
2500 rdp->aad = NULL;
2501 rdp->mcs = NULL;
2502 rdp->nego = NULL;
2503 rdp->license = NULL;
2504 rdp->transport = NULL;
2505 rdp->fastpath = NULL;
2506}
2507
2508BOOL rdp_reset(rdpRdp* rdp)
2509{
2510 BOOL rc = TRUE;
2511
2512 WINPR_ASSERT(rdp);
2513
2514 rdpSettings* settings = rdp->settings;
2515 WINPR_ASSERT(settings);
2516
2517 bulk_reset(rdp->bulk);
2518
2519 rdp_reset_free(rdp);
2520
2521 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerRandom, NULL, 0))
2522 rc = FALSE;
2523
2524 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerCertificate, NULL, 0))
2525 rc = FALSE;
2526
2527 if (!freerdp_settings_set_string(settings, FreeRDP_ClientAddress, NULL))
2528 rc = FALSE;
2529
2530 if (!rc)
2531 goto fail;
2532
2533 rc = rdp_new_common(rdp);
2534 if (!rc)
2535 goto fail;
2536
2537 if (!transport_set_layer(rdp->transport, TRANSPORT_LAYER_TCP))
2538 goto fail;
2539
2540 rdp->errorInfo = 0;
2541 rc = rdp_finalize_reset_flags(rdp, TRUE);
2542
2543fail:
2544 return rc;
2545}
2546
2552void rdp_free(rdpRdp* rdp)
2553{
2554 if (rdp)
2555 {
2556 freerdp_timer_free(rdp->timer);
2557 rdp_reset_free(rdp);
2558
2559 freerdp_settings_free(rdp->settings);
2560 freerdp_settings_free(rdp->originalSettings);
2561 freerdp_settings_free(rdp->remoteSettings);
2562
2563 input_free(rdp->input);
2564 update_free(rdp->update);
2565 nla_free(rdp->nla);
2566 redirection_free(rdp->redirection);
2567 autodetect_free(rdp->autodetect);
2568 heartbeat_free(rdp->heartbeat);
2569 multitransport_free(rdp->multitransport);
2570 bulk_free(rdp->bulk);
2571 free(rdp->io);
2572 PubSub_Free(rdp->pubSub);
2573 if (rdp->abortEvent)
2574 (void)CloseHandle(rdp->abortEvent);
2575 aad_free(rdp->aad);
2576 WINPR_JSON_Delete(rdp->wellknown);
2577 DeleteCriticalSection(&rdp->critical);
2578 free(rdp);
2579 }
2580}
2581
2582BOOL rdp_io_callback_set_event(rdpRdp* rdp, BOOL set)
2583{
2584 if (!rdp)
2585 return FALSE;
2586 return transport_io_callback_set_event(rdp->transport, set);
2587}
2588
2589const rdpTransportIo* rdp_get_io_callbacks(rdpRdp* rdp)
2590{
2591 if (!rdp)
2592 return NULL;
2593 return rdp->io;
2594}
2595
2596BOOL rdp_set_io_callbacks(rdpRdp* rdp, const rdpTransportIo* io_callbacks)
2597{
2598 if (!rdp)
2599 return FALSE;
2600 free(rdp->io);
2601 rdp->io = NULL;
2602 if (io_callbacks)
2603 {
2604 rdp->io = malloc(sizeof(rdpTransportIo));
2605 if (!rdp->io)
2606 return FALSE;
2607 *rdp->io = *io_callbacks;
2608 return transport_set_io_callbacks(rdp->transport, rdp->io);
2609 }
2610 return TRUE;
2611}
2612
2613BOOL rdp_set_io_callback_context(rdpRdp* rdp, void* usercontext)
2614{
2615 WINPR_ASSERT(rdp);
2616 rdp->ioContext = usercontext;
2617 return TRUE;
2618}
2619
2620void* rdp_get_io_callback_context(rdpRdp* rdp)
2621{
2622 WINPR_ASSERT(rdp);
2623 return rdp->ioContext;
2624}
2625
2626const char* rdp_finalize_flags_to_str(UINT32 flags, char* buffer, size_t size)
2627{
2628 char number[32] = { 0 };
2629 const UINT32 mask =
2630 (uint32_t)~(FINALIZE_SC_SYNCHRONIZE_PDU | FINALIZE_SC_CONTROL_COOPERATE_PDU |
2631 FINALIZE_SC_CONTROL_GRANTED_PDU | FINALIZE_SC_FONT_MAP_PDU |
2632 FINALIZE_CS_SYNCHRONIZE_PDU | FINALIZE_CS_CONTROL_COOPERATE_PDU |
2633 FINALIZE_CS_CONTROL_REQUEST_PDU | FINALIZE_CS_PERSISTENT_KEY_LIST_PDU |
2634 FINALIZE_CS_FONT_LIST_PDU | FINALIZE_DEACTIVATE_REACTIVATE);
2635
2636 if (flags & FINALIZE_SC_SYNCHRONIZE_PDU)
2637 winpr_str_append("FINALIZE_SC_SYNCHRONIZE_PDU", buffer, size, "|");
2638 if (flags & FINALIZE_SC_CONTROL_COOPERATE_PDU)
2639 winpr_str_append("FINALIZE_SC_CONTROL_COOPERATE_PDU", buffer, size, "|");
2640 if (flags & FINALIZE_SC_CONTROL_GRANTED_PDU)
2641 winpr_str_append("FINALIZE_SC_CONTROL_GRANTED_PDU", buffer, size, "|");
2642 if (flags & FINALIZE_SC_FONT_MAP_PDU)
2643 winpr_str_append("FINALIZE_SC_FONT_MAP_PDU", buffer, size, "|");
2644 if (flags & FINALIZE_CS_SYNCHRONIZE_PDU)
2645 winpr_str_append("FINALIZE_CS_SYNCHRONIZE_PDU", buffer, size, "|");
2646 if (flags & FINALIZE_CS_CONTROL_COOPERATE_PDU)
2647 winpr_str_append("FINALIZE_CS_CONTROL_COOPERATE_PDU", buffer, size, "|");
2648 if (flags & FINALIZE_CS_CONTROL_REQUEST_PDU)
2649 winpr_str_append("FINALIZE_CS_CONTROL_REQUEST_PDU", buffer, size, "|");
2650 if (flags & FINALIZE_CS_PERSISTENT_KEY_LIST_PDU)
2651 winpr_str_append("FINALIZE_CS_PERSISTENT_KEY_LIST_PDU", buffer, size, "|");
2652 if (flags & FINALIZE_CS_FONT_LIST_PDU)
2653 winpr_str_append("FINALIZE_CS_FONT_LIST_PDU", buffer, size, "|");
2654 if (flags & FINALIZE_DEACTIVATE_REACTIVATE)
2655 winpr_str_append("FINALIZE_DEACTIVATE_REACTIVATE", buffer, size, "|");
2656 if (flags & mask)
2657 winpr_str_append("UNKNOWN_FLAG", buffer, size, "|");
2658 if (flags == 0)
2659 winpr_str_append("NO_FLAG_SET", buffer, size, "|");
2660 (void)_snprintf(number, sizeof(number), " [0x%08" PRIx32 "]", flags);
2661 winpr_str_append(number, buffer, size, "");
2662 return buffer;
2663}
2664
2665BOOL rdp_finalize_reset_flags(rdpRdp* rdp, BOOL clearAll)
2666{
2667 WINPR_ASSERT(rdp);
2668 WLog_Print(rdp->log, WLOG_DEBUG, "[%s] reset finalize_sc_pdus", rdp_get_state_string(rdp));
2669 if (clearAll)
2670 rdp->finalize_sc_pdus = 0;
2671 else
2672 rdp->finalize_sc_pdus &= FINALIZE_DEACTIVATE_REACTIVATE;
2673
2674 return rdp_set_monitor_layout_pdu_state(rdp, FALSE);
2675}
2676
2677BOOL rdp_finalize_set_flag(rdpRdp* rdp, UINT32 flag)
2678{
2679 char buffer[1024] = { 0 };
2680
2681 WINPR_ASSERT(rdp);
2682
2683 WLog_Print(rdp->log, WLOG_DEBUG, "[%s] received flag %s", rdp_get_state_string(rdp),
2684 rdp_finalize_flags_to_str(flag, buffer, sizeof(buffer)));
2685 rdp->finalize_sc_pdus |= flag;
2686 return TRUE;
2687}
2688
2689BOOL rdp_finalize_is_flag_set(rdpRdp* rdp, UINT32 flag)
2690{
2691 WINPR_ASSERT(rdp);
2692 return (rdp->finalize_sc_pdus & flag) == flag;
2693}
2694
2695BOOL rdp_reset_rc4_encrypt_keys(rdpRdp* rdp)
2696{
2697 WINPR_ASSERT(rdp);
2698 rdp_free_rc4_encrypt_keys(rdp);
2699 rdp->rc4_encrypt_key = winpr_RC4_New(rdp->encrypt_key, rdp->rc4_key_len);
2700
2701 rdp->encrypt_use_count = 0;
2702 return rdp->rc4_encrypt_key != NULL;
2703}
2704
2705void rdp_free_rc4_encrypt_keys(rdpRdp* rdp)
2706{
2707 WINPR_ASSERT(rdp);
2708 winpr_RC4_Free(rdp->rc4_encrypt_key);
2709 rdp->rc4_encrypt_key = NULL;
2710}
2711
2712void rdp_free_rc4_decrypt_keys(rdpRdp* rdp)
2713{
2714 WINPR_ASSERT(rdp);
2715 winpr_RC4_Free(rdp->rc4_decrypt_key);
2716 rdp->rc4_decrypt_key = NULL;
2717}
2718
2719BOOL rdp_reset_rc4_decrypt_keys(rdpRdp* rdp)
2720{
2721 WINPR_ASSERT(rdp);
2722 rdp_free_rc4_decrypt_keys(rdp);
2723 rdp->rc4_decrypt_key = winpr_RC4_New(rdp->decrypt_key, rdp->rc4_key_len);
2724
2725 rdp->decrypt_use_count = 0;
2726 return rdp->rc4_decrypt_key != NULL;
2727}
2728
2729const char* rdp_security_flag_string(UINT32 securityFlags, char* buffer, size_t size)
2730{
2731 if (securityFlags & SEC_EXCHANGE_PKT)
2732 winpr_str_append("SEC_EXCHANGE_PKT", buffer, size, "|");
2733 if (securityFlags & SEC_TRANSPORT_REQ)
2734 winpr_str_append("SEC_TRANSPORT_REQ", buffer, size, "|");
2735 if (securityFlags & SEC_TRANSPORT_RSP)
2736 winpr_str_append("SEC_TRANSPORT_RSP", buffer, size, "|");
2737 if (securityFlags & SEC_ENCRYPT)
2738 winpr_str_append("SEC_ENCRYPT", buffer, size, "|");
2739 if (securityFlags & SEC_RESET_SEQNO)
2740 winpr_str_append("SEC_RESET_SEQNO", buffer, size, "|");
2741 if (securityFlags & SEC_IGNORE_SEQNO)
2742 winpr_str_append("SEC_IGNORE_SEQNO", buffer, size, "|");
2743 if (securityFlags & SEC_INFO_PKT)
2744 winpr_str_append("SEC_INFO_PKT", buffer, size, "|");
2745 if (securityFlags & SEC_LICENSE_PKT)
2746 winpr_str_append("SEC_LICENSE_PKT", buffer, size, "|");
2747 if (securityFlags & SEC_LICENSE_ENCRYPT_CS)
2748 winpr_str_append("SEC_LICENSE_ENCRYPT_CS", buffer, size, "|");
2749 if (securityFlags & SEC_LICENSE_ENCRYPT_SC)
2750 winpr_str_append("SEC_LICENSE_ENCRYPT_SC", buffer, size, "|");
2751 if (securityFlags & SEC_REDIRECTION_PKT)
2752 winpr_str_append("SEC_REDIRECTION_PKT", buffer, size, "|");
2753 if (securityFlags & SEC_SECURE_CHECKSUM)
2754 winpr_str_append("SEC_SECURE_CHECKSUM", buffer, size, "|");
2755 if (securityFlags & SEC_AUTODETECT_REQ)
2756 winpr_str_append("SEC_AUTODETECT_REQ", buffer, size, "|");
2757 if (securityFlags & SEC_AUTODETECT_RSP)
2758 winpr_str_append("SEC_AUTODETECT_RSP", buffer, size, "|");
2759 if (securityFlags & SEC_HEARTBEAT)
2760 winpr_str_append("SEC_HEARTBEAT", buffer, size, "|");
2761 if (securityFlags & SEC_FLAGSHI_VALID)
2762 winpr_str_append("SEC_FLAGSHI_VALID", buffer, size, "|");
2763 {
2764 char msg[32] = { 0 };
2765
2766 (void)_snprintf(msg, sizeof(msg), "[0x%08" PRIx32 "]", securityFlags);
2767 winpr_str_append(msg, buffer, size, "");
2768 }
2769 return buffer;
2770}
2771
2772static BOOL rdp_reset_remote_settings(rdpRdp* rdp)
2773{
2774 UINT32 flags = FREERDP_SETTINGS_REMOTE_MODE;
2775 WINPR_ASSERT(rdp);
2776 freerdp_settings_free(rdp->remoteSettings);
2777
2778 if (!freerdp_settings_get_bool(rdp->settings, FreeRDP_ServerMode))
2779 flags |= FREERDP_SETTINGS_SERVER_MODE;
2780 rdp->remoteSettings = freerdp_settings_new(flags);
2781 return rdp->remoteSettings != NULL;
2782}
2783
2784BOOL rdp_set_backup_settings(rdpRdp* rdp)
2785{
2786 WINPR_ASSERT(rdp);
2787 freerdp_settings_free(rdp->originalSettings);
2788 rdp->originalSettings = freerdp_settings_clone(rdp->settings);
2789 if (!rdp->originalSettings)
2790 return FALSE;
2791 return rdp_reset_remote_settings(rdp);
2792}
2793
2794BOOL rdp_reset_runtime_settings(rdpRdp* rdp)
2795{
2796 WINPR_ASSERT(rdp);
2797 WINPR_ASSERT(rdp->context);
2798
2799 freerdp_settings_free(rdp->settings);
2800 rdp->context->settings = rdp->settings = freerdp_settings_clone(rdp->originalSettings);
2801
2802 if (!rdp->settings)
2803 return FALSE;
2804 return rdp_reset_remote_settings(rdp);
2805}
2806
2807static BOOL starts_with(const char* tok, const char* val)
2808{
2809 const size_t len = strlen(val);
2810 if (strncmp(tok, val, len) != 0)
2811 return FALSE;
2812 if (tok[len] != '=')
2813 return FALSE;
2814 return TRUE;
2815}
2816
2817static BOOL option_equals(const char* what, const char* val)
2818{
2819 return _stricmp(what, val) == 0;
2820}
2821
2822static BOOL parse_on_off_option(const char* value)
2823{
2824 WINPR_ASSERT(value);
2825 const char* sep = strchr(value, '=');
2826 if (!sep)
2827 return TRUE;
2828 if (option_equals("on", &sep[1]))
2829 return TRUE;
2830 if (option_equals("true", &sep[1]))
2831 return TRUE;
2832 if (option_equals("off", &sep[1]))
2833 return FALSE;
2834 if (option_equals("false", &sep[1]))
2835 return FALSE;
2836
2837 errno = 0;
2838 long val = strtol(value, NULL, 0);
2839 if (errno == 0)
2840 return val == 0 ? FALSE : TRUE;
2841
2842 return FALSE;
2843}
2844
2845#define STR(x) #x
2846
2847static BOOL option_is_runtime_checks(WINPR_ATTR_UNUSED wLog* log, const char* tok)
2848{
2849 const char* experimental[] = { STR(WITH_VERBOSE_WINPR_ASSERT) };
2850 for (size_t x = 0; x < ARRAYSIZE(experimental); x++)
2851 {
2852 const char* opt = experimental[x];
2853 if (starts_with(tok, opt))
2854 {
2855 return parse_on_off_option(tok);
2856 }
2857 }
2858 return FALSE;
2859}
2860
2861static BOOL option_is_experimental(WINPR_ATTR_UNUSED wLog* log, const char* tok)
2862{
2863 const char* experimental[] = { STR(WITH_DSP_EXPERIMENTAL), STR(WITH_VAAPI) };
2864 for (size_t x = 0; x < ARRAYSIZE(experimental); x++)
2865 {
2866 const char* opt = experimental[x];
2867 if (starts_with(tok, opt))
2868 {
2869 return parse_on_off_option(tok);
2870 }
2871 }
2872 return FALSE;
2873}
2874
2875static BOOL option_is_debug(wLog* log, const char* tok)
2876{
2877 WINPR_ASSERT(log);
2878 const char* debug[] = { STR(WITH_DEBUG_ALL),
2879 STR(WITH_DEBUG_CERTIFICATE),
2880 STR(WITH_DEBUG_CAPABILITIES),
2881 STR(WITH_DEBUG_CHANNELS),
2882 STR(WITH_DEBUG_CLIPRDR),
2883 STR(WITH_DEBUG_CODECS),
2884 STR(WITH_DEBUG_RDPGFX),
2885 STR(WITH_DEBUG_DVC),
2886 STR(WITH_DEBUG_TSMF),
2887 STR(WITH_DEBUG_KBD),
2888 STR(WITH_DEBUG_LICENSE),
2889 STR(WITH_DEBUG_NEGO),
2890 STR(WITH_DEBUG_NLA),
2891 STR(WITH_DEBUG_TSG),
2892 STR(WITH_DEBUG_RAIL),
2893 STR(WITH_DEBUG_RDP),
2894 STR(WITH_DEBUG_RDPEI),
2895 STR(WITH_DEBUG_REDIR),
2896 STR(WITH_DEBUG_RDPDR),
2897 STR(WITH_DEBUG_RFX),
2898 STR(WITH_DEBUG_SCARD),
2899 STR(WITH_DEBUG_SND),
2900 STR(WITH_DEBUG_SVC),
2901 STR(WITH_DEBUG_TRANSPORT),
2902 STR(WITH_DEBUG_TIMEZONE),
2903 STR(WITH_DEBUG_WND),
2904 STR(WITH_DEBUG_X11_CLIPRDR),
2905 STR(WITH_DEBUG_X11_LOCAL_MOVESIZE),
2906 STR(WITH_DEBUG_X11),
2907 STR(WITH_DEBUG_XV),
2908 STR(WITH_DEBUG_RINGBUFFER),
2909 STR(WITH_DEBUG_SYMBOLS),
2910 STR(WITH_DEBUG_EVENTS),
2911 STR(WITH_DEBUG_MUTEX),
2912 STR(WITH_DEBUG_NTLM),
2913 STR(WITH_DEBUG_SDL_EVENTS),
2914 STR(WITH_DEBUG_SDL_KBD_EVENTS),
2915 STR(WITH_DEBUG_THREADS),
2916 STR(WITH_DEBUG_URBDRC) };
2917
2918 for (size_t x = 0; x < ARRAYSIZE(debug); x++)
2919 {
2920 const char* opt = debug[x];
2921 if (starts_with(tok, opt))
2922 return parse_on_off_option(tok);
2923 }
2924
2925 if (starts_with(tok, "WITH_DEBUG"))
2926 {
2927 WLog_Print(log, WLOG_WARN, "[BUG] Unmapped Debug-Build option '%s'.", tok);
2928 return parse_on_off_option(tok);
2929 }
2930
2931 return FALSE;
2932}
2933
2934static void log_build_warn(rdpRdp* rdp, const char* what, const char* msg,
2935 BOOL (*cmp)(wLog* log, const char* tok))
2936{
2937 WINPR_ASSERT(rdp);
2938 WINPR_PRAGMA_DIAG_PUSH
2939 WINPR_PRAGMA_DIAG_IGNORED_OVERLENGTH_STRINGS
2940
2941 size_t len = sizeof(FREERDP_BUILD_CONFIG);
2942 char* list = calloc(len, sizeof(char));
2943 char* config = _strdup(FREERDP_BUILD_CONFIG);
2944 WINPR_PRAGMA_DIAG_POP
2945
2946 if (config && list)
2947 {
2948 char* saveptr = NULL;
2949 char* tok = strtok_s(config, " ", &saveptr);
2950 while (tok)
2951 {
2952 if (cmp(rdp->log, tok))
2953 winpr_str_append(tok, list, len, " ");
2954
2955 tok = strtok_s(NULL, " ", &saveptr);
2956 }
2957 }
2958 free(config);
2959
2960 if (list)
2961 {
2962 if (strlen(list) > 0)
2963 {
2964 WLog_Print(rdp->log, WLOG_WARN, "*************************************************");
2965 WLog_Print(rdp->log, WLOG_WARN, "This build is using [%s] build options:", what);
2966
2967 char* saveptr = NULL;
2968 char* tok = strtok_s(list, " ", &saveptr);
2969 while (tok)
2970 {
2971 WLog_Print(rdp->log, WLOG_WARN, "* '%s'", tok);
2972 tok = strtok_s(NULL, " ", &saveptr);
2973 }
2974 WLog_Print(rdp->log, WLOG_WARN, "*");
2975 WLog_Print(rdp->log, WLOG_WARN, "[%s] build options %s", what, msg);
2976 WLog_Print(rdp->log, WLOG_WARN, "*************************************************");
2977 }
2978 }
2979 free(list);
2980}
2981
2982#define print_first_line(log, firstLine, what) \
2983 print_first_line_int((log), (firstLine), (what), __FILE__, __func__, __LINE__)
2984static void print_first_line_int(wLog* log, log_line_t* firstLine, const char* what,
2985 const char* file, const char* fkt, size_t line)
2986{
2987 WINPR_ASSERT(firstLine);
2988 if (!firstLine->fkt)
2989 {
2990 const DWORD level = WLOG_WARN;
2991 if (WLog_IsLevelActive(log, level))
2992 {
2993 WLog_PrintTextMessage(log, level, line, file, fkt,
2994 "*************************************************");
2995 WLog_PrintTextMessage(log, level, line, file, fkt,
2996 "[SSL] {%s} build or configuration missing:", what);
2997 }
2998 firstLine->line = line;
2999 firstLine->file = file;
3000 firstLine->fkt = fkt;
3001 firstLine->level = level;
3002 }
3003}
3004
3005static void print_last_line(wLog* log, const log_line_t* firstLine)
3006{
3007 WINPR_ASSERT(firstLine);
3008 if (firstLine->fkt)
3009 {
3010 if (WLog_IsLevelActive(log, firstLine->level))
3011 WLog_PrintTextMessage(log, firstLine->level, firstLine->line, firstLine->file,
3012 firstLine->fkt,
3013 "*************************************************");
3014 }
3015}
3016
3017static void log_build_warn_cipher(rdpRdp* rdp, log_line_t* firstLine, WINPR_CIPHER_TYPE md,
3018 const char* what)
3019{
3020 BOOL haveCipher = FALSE;
3021
3022 char key[WINPR_CIPHER_MAX_KEY_LENGTH] = { 0 };
3023 char iv[WINPR_CIPHER_MAX_IV_LENGTH] = { 0 };
3024
3025 /* RC4 only exists in the compatibility functions winpr_RC4_*
3026 * winpr_Cipher_* does not support that. */
3027 if (md == WINPR_CIPHER_ARC4_128)
3028 {
3029 WINPR_RC4_CTX* enc = winpr_RC4_New(key, sizeof(key));
3030 haveCipher = enc != NULL;
3031 winpr_RC4_Free(enc);
3032 }
3033 else
3034 {
3035 WINPR_CIPHER_CTX* enc =
3036 winpr_Cipher_NewEx(md, WINPR_ENCRYPT, key, sizeof(key), iv, sizeof(iv));
3037 WINPR_CIPHER_CTX* dec =
3038 winpr_Cipher_NewEx(md, WINPR_DECRYPT, key, sizeof(key), iv, sizeof(iv));
3039 if (enc && dec)
3040 haveCipher = TRUE;
3041
3042 winpr_Cipher_Free(enc);
3043 winpr_Cipher_Free(dec);
3044 }
3045
3046 if (!haveCipher)
3047 {
3048 print_first_line(rdp->log, firstLine, "Cipher");
3049 WLog_Print(rdp->log, WLOG_WARN, "* %s: %s", winpr_cipher_type_to_string(md), what);
3050 }
3051}
3052
3053static void log_build_warn_hmac(rdpRdp* rdp, log_line_t* firstLine, WINPR_MD_TYPE md,
3054 const char* what)
3055{
3056 BOOL haveHmacX = FALSE;
3057 WINPR_HMAC_CTX* hmac = winpr_HMAC_New();
3058 if (hmac)
3059 {
3060 /* We need some key length, but there is no real limit here.
3061 * just take the cipher maximum key length as we already have that available.
3062 */
3063 char key[WINPR_CIPHER_MAX_KEY_LENGTH] = { 0 };
3064 haveHmacX = winpr_HMAC_Init(hmac, md, key, sizeof(key));
3065 }
3066 winpr_HMAC_Free(hmac);
3067
3068 if (!haveHmacX)
3069 {
3070 print_first_line(rdp->log, firstLine, "HMAC");
3071 WLog_Print(rdp->log, WLOG_WARN, " * %s: %s", winpr_md_type_to_string(md), what);
3072 }
3073}
3074
3075static void log_build_warn_hash(rdpRdp* rdp, log_line_t* firstLine, WINPR_MD_TYPE md,
3076 const char* what)
3077{
3078 BOOL haveDigestX = FALSE;
3079
3080 WINPR_DIGEST_CTX* digest = winpr_Digest_New();
3081 if (digest)
3082 haveDigestX = winpr_Digest_Init(digest, md);
3083 winpr_Digest_Free(digest);
3084
3085 if (!haveDigestX)
3086 {
3087 print_first_line(rdp->log, firstLine, "Digest");
3088 WLog_Print(rdp->log, WLOG_WARN, " * %s: %s", winpr_md_type_to_string(md), what);
3089 }
3090}
3091
3092static void log_build_warn_ssl(rdpRdp* rdp)
3093{
3094 WINPR_ASSERT(rdp);
3095
3096 log_line_t firstHashLine = { 0 };
3097 log_build_warn_hash(rdp, &firstHashLine, WINPR_MD_MD4, "NTLM support not available");
3098 log_build_warn_hash(rdp, &firstHashLine, WINPR_MD_MD5,
3099 "NTLM, assistance files with encrypted passwords, autoreconnect cookies, "
3100 "licensing and RDP security will not work");
3101 log_build_warn_hash(rdp, &firstHashLine, WINPR_MD_SHA1,
3102 "assistance files with encrypted passwords, Kerberos, Smartcard Logon, RDP "
3103 "security support not available");
3104 log_build_warn_hash(
3105 rdp, &firstHashLine, WINPR_MD_SHA256,
3106 "file clipboard, AAD gateway, NLA security and certificates might not work");
3107 print_last_line(rdp->log, &firstHashLine);
3108
3109 log_line_t firstHmacLine = { 0 };
3110 log_build_warn_hmac(rdp, &firstHmacLine, WINPR_MD_MD5, "Autoreconnect cookie not supported");
3111 log_build_warn_hmac(rdp, &firstHmacLine, WINPR_MD_SHA1, "RDP security not supported");
3112 print_last_line(rdp->log, &firstHmacLine);
3113
3114 log_line_t firstCipherLine = { 0 };
3115 log_build_warn_cipher(rdp, &firstCipherLine, WINPR_CIPHER_ARC4_128,
3116 "assistance files with encrypted passwords, NTLM, RDP licensing and RDP "
3117 "security will not work");
3118 log_build_warn_cipher(rdp, &firstCipherLine, WINPR_CIPHER_DES_EDE3_CBC,
3119 "RDP security FIPS mode will not work");
3120 log_build_warn_cipher(
3121 rdp, &firstCipherLine, WINPR_CIPHER_AES_128_CBC,
3122 "assistance file encrypted LHTicket will not work and ARM gateway might not");
3123 log_build_warn_cipher(rdp, &firstCipherLine, WINPR_CIPHER_AES_192_CBC,
3124 "ARM gateway might not work");
3125 log_build_warn_cipher(rdp, &firstCipherLine, WINPR_CIPHER_AES_256_CBC,
3126 "ARM gateway might not work");
3127 print_last_line(rdp->log, &firstCipherLine);
3128}
3129
3130void rdp_log_build_warnings(rdpRdp* rdp)
3131{
3132 static unsigned count = 0;
3133
3134 WINPR_ASSERT(rdp);
3135 /* Since this function is called in context creation routines stop logging
3136 * this issue repeatedly. This is required for proxy, which would otherwise
3137 * spam the log with these. */
3138 if (count > 0)
3139 return;
3140 count++;
3141 log_build_warn(rdp, "experimental", "might crash the application", option_is_experimental);
3142 log_build_warn(rdp, "debug", "might leak sensitive information (credentials, ...)",
3143 option_is_debug);
3144 log_build_warn(rdp, "runtime-check", "might slow down the application",
3145 option_is_runtime_checks);
3146 log_build_warn_ssl(rdp);
3147}
3148
3149size_t rdp_get_event_handles(rdpRdp* rdp, HANDLE* handles, uint32_t count)
3150{
3151 size_t nCount = transport_get_event_handles(rdp->transport, handles, count);
3152
3153 if (nCount == 0)
3154 return 0;
3155
3156 if (count < nCount + 2UL)
3157 return 0;
3158
3159 handles[nCount++] = utils_get_abort_event(rdp);
3160 handles[nCount++] = freerdp_timer_get_event(rdp->timer);
3161 return nCount;
3162}
WINPR_JSON_Delete
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
Definition c-json.c:103
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:3746
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_settings_new
FREERDP_API rdpSettings * freerdp_settings_new(DWORD flags)
creates a new setting struct
Definition core/settings.c:762
freerdp_settings_clone
FREERDP_API rdpSettings * freerdp_settings_clone(const rdpSettings *settings)
Creates a deep copy of settings.
Definition core/settings.c:1531
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:1442
freerdp_settings_free
FREERDP_API void freerdp_settings_free(rdpSettings *settings)
Free a settings struct with all data in it.
Definition core/settings.c:1284
FREERDP_SETTINGS_SERVER_MODE
#define FREERDP_SETTINGS_SERVER_MODE
Definition include/freerdp/settings.h:80
MONITOR_DEF
Definition settings_types.h:405