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