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