FreeRDP
Loading...
Searching...
No Matches
peer.c
1
23#include <freerdp/config.h>
24
25#include "settings.h"
26
27#include <winpr/assert.h>
28#include <winpr/cast.h>
29#include <winpr/crt.h>
30#include <winpr/winsock.h>
31
32#include "info.h"
33#include "display.h"
34
35#include <freerdp/log.h>
36#include <freerdp/streamdump.h>
37#include <freerdp/redirection.h>
38#include <freerdp/crypto/certificate.h>
39
40#include "rdp.h"
41#include "peer.h"
42#include "multitransport.h"
43
44#define TAG FREERDP_TAG("core.peer")
45
46static state_run_t peer_recv_pdu(freerdp_peer* client, wStream* s);
47
48static HANDLE freerdp_peer_virtual_channel_open(freerdp_peer* client, const char* name,
49 UINT32 flags)
50{
51 UINT32 index = 0;
52 BOOL joined = FALSE;
53 rdpMcsChannel* mcsChannel = NULL;
54 rdpPeerChannel* peerChannel = NULL;
55 rdpMcs* mcs = NULL;
56
57 WINPR_ASSERT(client);
58 WINPR_ASSERT(client->context);
59 WINPR_ASSERT(client->context->rdp);
60 WINPR_ASSERT(name);
61 mcs = client->context->rdp->mcs;
62 WINPR_ASSERT(mcs);
63
64 if (flags & WTS_CHANNEL_OPTION_DYNAMIC)
65 return NULL; /* not yet supported */
66
67 const size_t length = strnlen(name, 9);
68
69 if (length > 8)
70 return NULL; /* SVC maximum name length is 8 */
71
72 for (; index < mcs->channelCount; index++)
73 {
74 mcsChannel = &(mcs->channels[index]);
75
76 if (!mcsChannel->joined)
77 continue;
78
79 if (_strnicmp(name, mcsChannel->Name, length) == 0)
80 {
81 joined = TRUE;
82 break;
83 }
84 }
85
86 if (!joined)
87 return NULL; /* channel is not joined */
88
89 peerChannel = (rdpPeerChannel*)mcsChannel->handle;
90
91 if (peerChannel)
92 {
93 /* channel is already open */
94 return (HANDLE)peerChannel;
95 }
96
97 WINPR_ASSERT(index <= UINT16_MAX);
98 peerChannel =
99 server_channel_common_new(client, (UINT16)index, mcsChannel->ChannelId, 128, NULL, name);
100
101 if (peerChannel)
102 {
103 peerChannel->channelFlags = flags;
104 peerChannel->mcsChannel = mcsChannel;
105 mcsChannel->handle = (void*)peerChannel;
106 }
107
108 return (HANDLE)peerChannel;
109}
110
111static BOOL freerdp_peer_virtual_channel_close(WINPR_ATTR_UNUSED freerdp_peer* client,
112 HANDLE hChannel)
113{
114 rdpMcsChannel* mcsChannel = NULL;
115 rdpPeerChannel* peerChannel = NULL;
116
117 WINPR_ASSERT(client);
118
119 if (!hChannel)
120 return FALSE;
121
122 peerChannel = (rdpPeerChannel*)hChannel;
123 mcsChannel = peerChannel->mcsChannel;
124 WINPR_ASSERT(mcsChannel);
125 mcsChannel->handle = NULL;
126 server_channel_common_free(peerChannel);
127 return TRUE;
128}
129
130static int freerdp_peer_virtual_channel_write(freerdp_peer* client, HANDLE hChannel,
131 const BYTE* buffer, UINT32 length)
132{
133 wStream* s = NULL;
134 UINT32 flags = 0;
135 UINT32 chunkSize = 0;
136 UINT32 maxChunkSize = 0;
137 UINT32 totalLength = 0;
138 rdpPeerChannel* peerChannel = NULL;
139 rdpMcsChannel* mcsChannel = NULL;
140 rdpRdp* rdp = NULL;
141
142 WINPR_ASSERT(client);
143 WINPR_ASSERT(client->context);
144
145 rdp = client->context->rdp;
146 WINPR_ASSERT(rdp);
147 WINPR_ASSERT(rdp->settings);
148
149 if (!hChannel)
150 return -1;
151
152 peerChannel = (rdpPeerChannel*)hChannel;
153 mcsChannel = peerChannel->mcsChannel;
154 WINPR_ASSERT(peerChannel);
155 WINPR_ASSERT(mcsChannel);
156 if (peerChannel->channelFlags & WTS_CHANNEL_OPTION_DYNAMIC)
157 return -1; /* not yet supported */
158
159 maxChunkSize = rdp->settings->VCChunkSize;
160 totalLength = length;
161 flags = CHANNEL_FLAG_FIRST;
162
163 while (length > 0)
164 {
165 UINT16 sec_flags = 0;
166 s = rdp_send_stream_init(rdp, &sec_flags);
167
168 if (!s)
169 return -1;
170
171 if (length > maxChunkSize)
172 {
173 chunkSize = rdp->settings->VCChunkSize;
174 }
175 else
176 {
177 chunkSize = length;
178 flags |= CHANNEL_FLAG_LAST;
179 }
180
181 if (mcsChannel->options & CHANNEL_OPTION_SHOW_PROTOCOL)
182 flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
183
184 Stream_Write_UINT32(s, totalLength);
185 Stream_Write_UINT32(s, flags);
186
187 if (!Stream_EnsureRemainingCapacity(s, chunkSize))
188 {
189 Stream_Release(s);
190 return -1;
191 }
192
193 Stream_Write(s, buffer, chunkSize);
194
195 WINPR_ASSERT(peerChannel->channelId <= UINT16_MAX);
196 if (!rdp_send(rdp, s, (UINT16)peerChannel->channelId, sec_flags))
197 return -1;
198
199 buffer += chunkSize;
200 length -= chunkSize;
201 flags = 0;
202 }
203
204 return 1;
205}
206
207static void* freerdp_peer_virtual_channel_get_data(WINPR_ATTR_UNUSED freerdp_peer* client,
208 HANDLE hChannel)
209{
210 rdpPeerChannel* peerChannel = (rdpPeerChannel*)hChannel;
211
212 WINPR_ASSERT(client);
213 if (!hChannel)
214 return NULL;
215
216 return peerChannel->extra;
217}
218
219static int freerdp_peer_virtual_channel_set_data(WINPR_ATTR_UNUSED freerdp_peer* client,
220 HANDLE hChannel, void* data)
221{
222 rdpPeerChannel* peerChannel = (rdpPeerChannel*)hChannel;
223
224 WINPR_ASSERT(client);
225 if (!hChannel)
226 return -1;
227
228 peerChannel->extra = data;
229 return 1;
230}
231
232static BOOL freerdp_peer_set_state(freerdp_peer* client, CONNECTION_STATE state)
233{
234 WINPR_ASSERT(client);
235 WINPR_ASSERT(client->context);
236 return rdp_server_transition_to_state(client->context->rdp, state);
237}
238
239static BOOL freerdp_peer_initialize(freerdp_peer* client)
240{
241 rdpRdp* rdp = NULL;
242 rdpSettings* settings = NULL;
243
244 WINPR_ASSERT(client);
245 WINPR_ASSERT(client->context);
246
247 rdp = client->context->rdp;
248 WINPR_ASSERT(rdp);
249
250 settings = rdp->settings;
251 WINPR_ASSERT(settings);
252
253 settings->ServerMode = TRUE;
254 settings->FrameAcknowledge = 0;
255 settings->LocalConnection = client->local;
256
257 const rdpCertificate* cert =
258 freerdp_settings_get_pointer(settings, FreeRDP_RdpServerCertificate);
259 if (!cert)
260 {
261 WLog_ERR(TAG, "Missing server certificate, can not continue.");
262 return FALSE;
263 }
264
265 if (freerdp_settings_get_bool(settings, FreeRDP_RdpSecurity))
266 {
267
268 if (!freerdp_certificate_is_rdp_security_compatible(cert))
269 {
270 if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, FALSE))
271 return FALSE;
272 if (!freerdp_settings_set_bool(settings, FreeRDP_UseRdpSecurityLayer, FALSE))
273 return FALSE;
274 }
275 }
276
277 nego_set_RCG_supported(rdp->nego, settings->RemoteCredentialGuard);
278 nego_set_restricted_admin_mode_supported(rdp->nego, settings->RestrictedAdminModeSupported);
279
280 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_INITIAL))
281 return FALSE;
282
283 return TRUE;
284}
285
286#if defined(WITH_FREERDP_DEPRECATED)
287static BOOL freerdp_peer_get_fds(freerdp_peer* client, void** rfds, int* rcount)
288{
289 rdpTransport* transport = NULL;
290 WINPR_ASSERT(client);
291 WINPR_ASSERT(client->context);
292 WINPR_ASSERT(client->context->rdp);
293
294 transport = client->context->rdp->transport;
295 WINPR_ASSERT(transport);
296 transport_get_fds(transport, rfds, rcount);
297 return TRUE;
298}
299#endif
300
301static HANDLE freerdp_peer_get_event_handle(freerdp_peer* client)
302{
303 HANDLE hEvent = NULL;
304 rdpTransport* transport = NULL;
305 WINPR_ASSERT(client);
306 WINPR_ASSERT(client->context);
307 WINPR_ASSERT(client->context->rdp);
308
309 transport = client->context->rdp->transport;
310 hEvent = transport_get_front_bio(transport);
311 return hEvent;
312}
313
314static DWORD freerdp_peer_get_event_handles(freerdp_peer* client, HANDLE* events, DWORD count)
315{
316 WINPR_ASSERT(client);
317 WINPR_ASSERT(client->context);
318 WINPR_ASSERT(client->context->rdp);
319 return transport_get_event_handles(client->context->rdp->transport, events, count);
320}
321
322static BOOL freerdp_peer_check_fds(freerdp_peer* peer)
323{
324 int status = 0;
325 rdpRdp* rdp = NULL;
326
327 WINPR_ASSERT(peer);
328 WINPR_ASSERT(peer->context);
329
330 rdp = peer->context->rdp;
331 status = rdp_check_fds(rdp);
332
333 if (status < 0)
334 return FALSE;
335
336 return TRUE;
337}
338
339static state_run_t peer_recv_data_pdu(freerdp_peer* client, wStream* s,
340 WINPR_ATTR_UNUSED UINT16 totalLength)
341{
342 BYTE type = 0;
343 UINT16 length = 0;
344 UINT32 share_id = 0;
345 BYTE compressed_type = 0;
346 UINT16 compressed_len = 0;
347 rdpUpdate* update = NULL;
348
349 WINPR_ASSERT(s);
350 WINPR_ASSERT(client);
351 WINPR_ASSERT(client->context);
352 rdpRdp* rdp = client->context->rdp;
353 WINPR_ASSERT(rdp);
354 WINPR_ASSERT(rdp->mcs);
355
356 update = client->context->update;
357 WINPR_ASSERT(update);
358
359 if (!rdp_read_share_data_header(rdp, s, &length, &type, &share_id, &compressed_type,
360 &compressed_len))
361 return STATE_RUN_FAILED;
362
363#ifdef WITH_DEBUG_RDP
364 WLog_Print(rdp->log, WLOG_DEBUG, "recv %s Data PDU (0x%02" PRIX8 "), length: %" PRIu16 "",
365 data_pdu_type_to_string(type), type, length);
366#endif
367
368 switch (type)
369 {
370 case DATA_PDU_TYPE_SYNCHRONIZE:
371 if (!rdp_recv_client_synchronize_pdu(rdp, s))
372 return STATE_RUN_FAILED;
373
374 break;
375
376 case DATA_PDU_TYPE_CONTROL:
377 if (!rdp_server_accept_client_control_pdu(rdp, s))
378 return STATE_RUN_FAILED;
379
380 break;
381
382 case DATA_PDU_TYPE_INPUT:
383 if (!input_recv(rdp->input, s))
384 return STATE_RUN_FAILED;
385
386 break;
387
388 case DATA_PDU_TYPE_BITMAP_CACHE_PERSISTENT_LIST:
389 if (!rdp_server_accept_client_persistent_key_list_pdu(rdp, s))
390 return STATE_RUN_FAILED;
391 break;
392
393 case DATA_PDU_TYPE_FONT_LIST:
394 if (!rdp_server_accept_client_font_list_pdu(rdp, s))
395 return STATE_RUN_FAILED;
396
397 return STATE_RUN_CONTINUE; // State changed, trigger rerun
398
399 case DATA_PDU_TYPE_SHUTDOWN_REQUEST:
400 mcs_send_disconnect_provider_ultimatum(rdp->mcs,
401 Disconnect_Ultimatum_provider_initiated);
402 WLog_WARN(TAG, "disconnect provider ultimatum sent to peer, closing connection");
403 return STATE_RUN_QUIT_SESSION;
404
405 case DATA_PDU_TYPE_FRAME_ACKNOWLEDGE:
406 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
407 return STATE_RUN_FAILED;
408
409 Stream_Read_UINT32(s, client->ack_frame_id);
410 IFCALL(update->SurfaceFrameAcknowledge, update->context, client->ack_frame_id);
411 break;
412
413 case DATA_PDU_TYPE_REFRESH_RECT:
414 if (!update_read_refresh_rect(update, s))
415 return STATE_RUN_FAILED;
416
417 break;
418
419 case DATA_PDU_TYPE_SUPPRESS_OUTPUT:
420 if (!update_read_suppress_output(update, s))
421 return STATE_RUN_FAILED;
422
423 break;
424
425 default:
426 WLog_ERR(TAG, "Data PDU type %" PRIu8 "", type);
427 break;
428 }
429
430 return STATE_RUN_SUCCESS;
431}
432
433static state_run_t peer_recv_tpkt_pdu(freerdp_peer* client, wStream* s)
434{
435 state_run_t rc = STATE_RUN_SUCCESS;
436 UINT16 length = 0;
437 UINT16 pduType = 0;
438 UINT16 pduSource = 0;
439 UINT16 channelId = 0;
440 UINT16 securityFlags = 0;
441
442 WINPR_ASSERT(s);
443 WINPR_ASSERT(client);
444 WINPR_ASSERT(client->context);
445
446 rdpRdp* rdp = client->context->rdp;
447 WINPR_ASSERT(rdp);
448 WINPR_ASSERT(rdp->mcs);
449
450 rdpSettings* settings = client->context->settings;
451 WINPR_ASSERT(settings);
452
453 if (!rdp_read_header(rdp, s, &length, &channelId))
454 return STATE_RUN_FAILED;
455
456 rdp->inPackets++;
457 if (freerdp_shall_disconnect_context(rdp->context))
458 return STATE_RUN_SUCCESS;
459
460 if (rdp_get_state(rdp) <= CONNECTION_STATE_LICENSING)
461 {
462 return rdp_handle_message_channel(rdp, s, channelId, length);
463 }
464
465 if (!rdp_handle_optional_rdp_decryption(rdp, s, &length, &securityFlags))
466 return STATE_RUN_FAILED;
467
468 if (channelId == MCS_GLOBAL_CHANNEL_ID)
469 {
470 char buffer[256] = { 0 };
471 UINT16 pduLength = 0;
472 UINT16 remain = 0;
473 if (!rdp_read_share_control_header(rdp, s, &pduLength, &remain, &pduType, &pduSource))
474 return STATE_RUN_FAILED;
475
476 settings->PduSource = pduSource;
477
478 WLog_DBG(TAG, "Received %s", pdu_type_to_str(pduType, buffer, sizeof(buffer)));
479 switch (pduType)
480 {
481 case PDU_TYPE_DATA:
482 rc = peer_recv_data_pdu(client, s, pduLength);
483 break;
484
485 case PDU_TYPE_CONFIRM_ACTIVE:
486 if (!rdp_server_accept_confirm_active(rdp, s, pduLength))
487 return STATE_RUN_FAILED;
488
489 break;
490
491 case PDU_TYPE_FLOW_RESPONSE:
492 case PDU_TYPE_FLOW_STOP:
493 case PDU_TYPE_FLOW_TEST:
494 if (!Stream_SafeSeek(s, remain))
495 {
496 WLog_WARN(TAG, "Short PDU, need %" PRIu16 " bytes, got %" PRIuz, remain,
497 Stream_GetRemainingLength(s));
498 return STATE_RUN_FAILED;
499 }
500 break;
501
502 default:
503 WLog_ERR(TAG, "Client sent unknown pduType %" PRIu16 "", pduType);
504 return STATE_RUN_FAILED;
505 }
506 }
507 else if ((rdp->mcs->messageChannelId > 0) && (channelId == rdp->mcs->messageChannelId))
508 {
509 if (!settings->UseRdpSecurityLayer)
510 {
511 if (!rdp_read_security_header(rdp, s, &securityFlags, NULL))
512 return STATE_RUN_FAILED;
513 }
514
515 return rdp_recv_message_channel_pdu(rdp, s, securityFlags);
516 }
517 else
518 {
519 if (!freerdp_channel_peer_process(client, s, channelId))
520 return STATE_RUN_FAILED;
521 }
522 if (!tpkt_ensure_stream_consumed(rdp->log, s, length))
523 return STATE_RUN_FAILED;
524
525 return rc;
526}
527
528static state_run_t peer_recv_handle_auto_detect(freerdp_peer* client, wStream* s)
529{
530 state_run_t ret = STATE_RUN_FAILED;
531 rdpRdp* rdp = NULL;
532
533 WINPR_ASSERT(client);
534 WINPR_ASSERT(s);
535 WINPR_ASSERT(client->context);
536
537 rdp = client->context->rdp;
538 WINPR_ASSERT(rdp);
539
540 const rdpSettings* settings = client->context->settings;
541 WINPR_ASSERT(settings);
542
543 if (freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect))
544 {
545 switch (rdp_get_state(rdp))
546 {
547 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_REQUEST:
548 autodetect_on_connect_time_auto_detect_begin(rdp->autodetect);
549 switch (autodetect_get_state(rdp->autodetect))
550 {
551 case FREERDP_AUTODETECT_STATE_REQUEST:
552 ret = STATE_RUN_SUCCESS;
553 if (!rdp_server_transition_to_state(
554 rdp, CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_RESPONSE))
555 return STATE_RUN_FAILED;
556 break;
557 case FREERDP_AUTODETECT_STATE_COMPLETE:
558 ret = STATE_RUN_CONTINUE; /* Rerun in next state */
559 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_LICENSING))
560 return STATE_RUN_FAILED;
561 break;
562 default:
563 break;
564 }
565 break;
566 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_RESPONSE:
567 ret = peer_recv_pdu(client, s);
568 if (state_run_success(ret))
569 {
570 autodetect_on_connect_time_auto_detect_progress(rdp->autodetect);
571 switch (autodetect_get_state(rdp->autodetect))
572 {
573 case FREERDP_AUTODETECT_STATE_REQUEST:
574 ret = STATE_RUN_SUCCESS;
575 break;
576 case FREERDP_AUTODETECT_STATE_COMPLETE:
577 ret = STATE_RUN_CONTINUE; /* Rerun in next state */
578 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_LICENSING))
579 return STATE_RUN_FAILED;
580 break;
581 default:
582 break;
583 }
584 }
585 break;
586 default:
587 WINPR_ASSERT(FALSE);
588 break;
589 }
590 }
591 else
592 {
593 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_LICENSING))
594 return STATE_RUN_FAILED;
595
596 ret = STATE_RUN_CONTINUE; /* Rerun in next state */
597 }
598
599 return ret;
600}
601
602static state_run_t peer_recv_handle_licensing(freerdp_peer* client, wStream* s)
603{
604 state_run_t ret = STATE_RUN_FAILED;
605 rdpRdp* rdp = NULL;
606 rdpSettings* settings = NULL;
607
608 WINPR_ASSERT(client);
609 WINPR_ASSERT(s);
610 WINPR_ASSERT(client->context);
611
612 rdp = client->context->rdp;
613 WINPR_ASSERT(rdp);
614
615 settings = rdp->settings;
616 WINPR_ASSERT(settings);
617
618 switch (license_get_state(rdp->license))
619 {
620 case LICENSE_STATE_INITIAL:
621 {
622 const BOOL required =
623 freerdp_settings_get_bool(settings, FreeRDP_ServerLicenseRequired);
624
625 if (required)
626 {
627 if (!license_server_configure(rdp->license))
628 ret = STATE_RUN_FAILED;
629 else if (!license_server_send_request(rdp->license))
630 ret = STATE_RUN_FAILED;
631 else
632 ret = STATE_RUN_SUCCESS;
633 }
634 else
635 {
636 if (license_send_valid_client_error_packet(rdp))
637 ret = STATE_RUN_CONTINUE; /* Rerun in next state, might be capabilities */
638 }
639 }
640 break;
641 case LICENSE_STATE_COMPLETED:
642 ret = STATE_RUN_CONTINUE; /* Licensing completed, continue in next state */
643 break;
644 case LICENSE_STATE_ABORTED:
645 ret = STATE_RUN_FAILED;
646 break;
647 default:
648 ret = peer_recv_pdu(client, s);
649 break;
650 }
651
652 return ret;
653}
654
655static state_run_t peer_recv_fastpath_pdu(freerdp_peer* client, wStream* s)
656{
657 rdpRdp* rdp = NULL;
658 UINT16 length = 0;
659 BOOL rc = 0;
660 rdpFastPath* fastpath = NULL;
661
662 WINPR_ASSERT(s);
663 WINPR_ASSERT(client);
664 WINPR_ASSERT(client->context);
665
666 rdp = client->context->rdp;
667 WINPR_ASSERT(rdp);
668
669 fastpath = rdp->fastpath;
670 WINPR_ASSERT(fastpath);
671
672 rc = fastpath_read_header_rdp(fastpath, s, &length);
673
674 if (!rc || (length == 0))
675 {
676 WLog_ERR(TAG, "incorrect FastPath PDU header length %" PRIu16 "", length);
677 return STATE_RUN_FAILED;
678 }
679 if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
680 return STATE_RUN_FAILED;
681
682 if (!fastpath_decrypt(fastpath, s, &length))
683 return STATE_RUN_FAILED;
684
685 rdp->inPackets++;
686
687 return fastpath_recv_inputs(fastpath, s);
688}
689
690state_run_t peer_recv_pdu(freerdp_peer* client, wStream* s)
691{
692 int rc = tpkt_verify_header(s);
693
694 if (rc > 0)
695 return peer_recv_tpkt_pdu(client, s);
696 else if (rc == 0)
697 return peer_recv_fastpath_pdu(client, s);
698 else
699 return STATE_RUN_FAILED;
700}
701
702static state_run_t peer_unexpected_client_message(rdpRdp* rdp, UINT32 flag)
703{
704 char buffer[1024] = { 0 };
705 WLog_WARN(TAG, "Unexpected client message in state %s, missing flag %s",
706 rdp_get_state_string(rdp), rdp_finalize_flags_to_str(flag, buffer, sizeof(buffer)));
707 return STATE_RUN_SUCCESS; /* we ignore this as per spec input PDU are already allowed */
708}
709
710state_run_t rdp_peer_handle_state_demand_active(freerdp_peer* client)
711{
712 state_run_t ret = STATE_RUN_FAILED;
713
714 WINPR_ASSERT(client);
715 WINPR_ASSERT(client->context);
716
717 rdpRdp* rdp = client->context->rdp;
718 WINPR_ASSERT(rdp);
719
720 if (client->Capabilities && !client->Capabilities(client))
721 {
722 WLog_ERR(TAG, "[%s] freerdp_peer::Capabilities() callback failed",
723 rdp_get_state_string(rdp));
724 }
725 else if (!rdp_send_demand_active(rdp))
726 {
727 WLog_ERR(TAG, "[%s] rdp_send_demand_active() fail", rdp_get_state_string(rdp));
728 }
729 else
730 {
731 if (!rdp_server_transition_to_state(rdp,
732 CONNECTION_STATE_CAPABILITIES_EXCHANGE_MONITOR_LAYOUT))
733 return STATE_RUN_FAILED;
734 ret = STATE_RUN_CONTINUE;
735 }
736 return ret;
737}
738
745static state_run_t rdp_peer_handle_state_active(freerdp_peer* client)
746{
747 state_run_t ret = STATE_RUN_FAILED;
748
749 WINPR_ASSERT(client);
750 WINPR_ASSERT(client->context);
751
752 if (!client->connected)
753 {
758 IFCALLRET(client->PostConnect, client->connected, client);
759 }
760 if (!client->connected)
761 {
762 WLog_ERR(TAG, "PostConnect for peer %p failed", WINPR_CXX_COMPAT_CAST(const void*, client));
763 ret = STATE_RUN_FAILED;
764 }
765 else if (!client->activated)
766 {
767 BOOL activated = TRUE;
768
769 /* Set client->activated TRUE before calling the Activate callback.
770 * the Activate callback might reset the client->activated flag even if it returns success
771 * (e.g. deactivate/reactivate sequence) */
772 client->activated = TRUE;
773 IFCALLRET(client->Activate, activated, client);
774
775 if (!activated)
776 {
777 WLog_ERR(TAG, "Activate for peer %p failed",
778 WINPR_CXX_COMPAT_CAST(const void*, client));
779 ret = STATE_RUN_FAILED;
780 }
781 else
782 ret = STATE_RUN_SUCCESS;
783 }
784 else
785 ret = STATE_RUN_ACTIVE;
786 return ret;
787}
788
789static state_run_t peer_recv_callback_internal(WINPR_ATTR_UNUSED rdpTransport* transport,
790 wStream* s, void* extra)
791{
792 UINT32 SelectedProtocol = 0;
793 freerdp_peer* client = (freerdp_peer*)extra;
794 rdpRdp* rdp = NULL;
795 state_run_t ret = STATE_RUN_FAILED;
796 rdpSettings* settings = NULL;
797
798 WINPR_ASSERT(transport);
799 WINPR_ASSERT(client);
800 WINPR_ASSERT(client->context);
801
802 rdp = client->context->rdp;
803 WINPR_ASSERT(rdp);
804
805 settings = client->context->settings;
806 WINPR_ASSERT(settings);
807
808 IFCALL(client->ReachedState, client, rdp_get_state(rdp));
809 switch (rdp_get_state(rdp))
810 {
811 case CONNECTION_STATE_INITIAL:
812 if (!freerdp_settings_enforce_consistency(settings))
813 ret = STATE_RUN_FAILED;
814 else if (rdp_server_transition_to_state(rdp, CONNECTION_STATE_NEGO))
815 ret = STATE_RUN_CONTINUE;
816 break;
817
818 case CONNECTION_STATE_NEGO:
819 if (!rdp_server_accept_nego(rdp, s))
820 {
821 WLog_ERR(TAG, "%s - rdp_server_accept_nego() fail", rdp_get_state_string(rdp));
822 }
823 else
824 {
825 SelectedProtocol = nego_get_selected_protocol(rdp->nego);
826 settings->RdstlsSecurity = (SelectedProtocol & PROTOCOL_RDSTLS) ? TRUE : FALSE;
827 settings->NlaSecurity = (SelectedProtocol & PROTOCOL_HYBRID) ? TRUE : FALSE;
828 settings->TlsSecurity = (SelectedProtocol & PROTOCOL_SSL) ? TRUE : FALSE;
829 settings->RdpSecurity = (SelectedProtocol == PROTOCOL_RDP) ? TRUE : FALSE;
830
831 if (SelectedProtocol & PROTOCOL_HYBRID)
832 {
833 SEC_WINNT_AUTH_IDENTITY_INFO* identity =
834 (SEC_WINNT_AUTH_IDENTITY_INFO*)nego_get_identity(rdp->nego);
835 sspi_CopyAuthIdentity(&client->identity, identity);
836 IFCALLRET(client->Logon, client->authenticated, client, &client->identity,
837 TRUE);
838 nego_free_nla(rdp->nego);
839 }
840 else
841 {
842 IFCALLRET(client->Logon, client->authenticated, client, &client->identity,
843 FALSE);
844 }
845 if (rdp_server_transition_to_state(rdp, CONNECTION_STATE_MCS_CREATE_REQUEST))
846 ret = STATE_RUN_SUCCESS;
847 }
848 break;
849
850 case CONNECTION_STATE_NLA:
851 WINPR_ASSERT(FALSE); // TODO
852 break;
853
854 case CONNECTION_STATE_MCS_CREATE_REQUEST:
855 if (!rdp_server_accept_mcs_connect_initial(rdp, s))
856 {
857 WLog_ERR(TAG,
858 "%s - "
859 "rdp_server_accept_mcs_connect_initial() fail",
860 rdp_get_state_string(rdp));
861 }
862 else
863 ret = STATE_RUN_SUCCESS;
864
865 break;
866
867 case CONNECTION_STATE_MCS_ERECT_DOMAIN:
868 if (!rdp_server_accept_mcs_erect_domain_request(rdp, s))
869 {
870 WLog_ERR(TAG,
871 "%s - "
872 "rdp_server_accept_mcs_erect_domain_request() fail",
873 rdp_get_state_string(rdp));
874 }
875 else
876 ret = STATE_RUN_SUCCESS;
877
878 break;
879
880 case CONNECTION_STATE_MCS_ATTACH_USER:
881 if (!rdp_server_accept_mcs_attach_user_request(rdp, s))
882 {
883 WLog_ERR(TAG,
884 "%s - "
885 "rdp_server_accept_mcs_attach_user_request() fail",
886 rdp_get_state_string(rdp));
887 }
888 else
889 ret = STATE_RUN_SUCCESS;
890
891 break;
892
893 case CONNECTION_STATE_MCS_CHANNEL_JOIN_REQUEST:
894 if (!rdp_server_accept_mcs_channel_join_request(rdp, s))
895 {
896 WLog_ERR(TAG,
897 "%s - "
898 "rdp_server_accept_mcs_channel_join_request() fail",
899 rdp_get_state_string(rdp));
900 }
901 else
902 ret = STATE_RUN_SUCCESS;
903 break;
904
905 case CONNECTION_STATE_RDP_SECURITY_COMMENCEMENT:
906 ret = STATE_RUN_SUCCESS;
907
908 if (!rdp_server_establish_keys(rdp, s))
909 {
910 WLog_ERR(TAG,
911 "%s - "
912 "rdp_server_establish_keys() fail",
913 rdp_get_state_string(rdp));
914 ret = STATE_RUN_FAILED;
915 }
916
917 if (state_run_success(ret))
918 {
919 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE))
920 ret = STATE_RUN_FAILED;
921 else if (Stream_GetRemainingLength(s) > 0)
922 ret = STATE_RUN_CONTINUE; /* Rerun function */
923 }
924 break;
925
926 case CONNECTION_STATE_SECURE_SETTINGS_EXCHANGE:
927 if (rdp_recv_client_info(rdp, s))
928 {
929 if (rdp_server_transition_to_state(
930 rdp, CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_REQUEST))
931 ret = STATE_RUN_CONTINUE;
932 }
933 break;
934
935 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_REQUEST:
936 case CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_RESPONSE:
937 ret = peer_recv_handle_auto_detect(client, s);
938 break;
939
940 case CONNECTION_STATE_LICENSING:
941 ret = peer_recv_handle_licensing(client, s);
942 if (ret == STATE_RUN_CONTINUE)
943 {
944 if (!rdp_server_transition_to_state(
945 rdp, CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_REQUEST))
946 ret = STATE_RUN_FAILED;
947 }
948 break;
949
950 case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_REQUEST:
951 if (settings->SupportMultitransport &&
952 ((settings->MultitransportFlags & INITIATE_REQUEST_PROTOCOL_UDPFECR) != 0))
953 {
954 /* only UDP reliable for now, nobody does lossy UDP (MS-RDPUDP only) these days */
955 ret = multitransport_server_request(rdp->multitransport,
956 INITIATE_REQUEST_PROTOCOL_UDPFECR);
957 switch (ret)
958 {
959 case STATE_RUN_SUCCESS:
960 rdp_server_transition_to_state(
961 rdp, CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_RESPONSE);
962 break;
963 case STATE_RUN_CONTINUE:
964 /* mismatch on the supported kind of UDP transports */
965 rdp_server_transition_to_state(
966 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE);
967 break;
968 default:
969 break;
970 }
971 }
972 else
973 {
974 if (rdp_server_transition_to_state(
975 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE))
976 ret = STATE_RUN_CONTINUE; /* Rerun, initialize next state */
977 }
978 break;
979 case CONNECTION_STATE_MULTITRANSPORT_BOOTSTRAPPING_RESPONSE:
980 ret = peer_recv_pdu(client, s);
981 break;
982
983 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_DEMAND_ACTIVE:
984 ret = rdp_peer_handle_state_demand_active(client);
985 break;
986
987 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_MONITOR_LAYOUT:
988 if (freerdp_settings_get_bool(settings, FreeRDP_SupportMonitorLayoutPdu))
989 {
990 MONITOR_DEF* monitors = NULL;
991
992 IFCALL(client->AdjustMonitorsLayout, client);
993
994 /* client supports the monitorLayout PDU, let's send him the monitors if any */
995 ret = STATE_RUN_SUCCESS;
996 if (freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount) == 0)
997 {
998 const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
999 const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
1000 const rdpMonitor primary = { .x = 0,
1001 .y = 0,
1002 .width = WINPR_ASSERTING_INT_CAST(int32_t, w),
1003 .height = WINPR_ASSERTING_INT_CAST(int32_t, h),
1004 .is_primary = TRUE,
1005 .orig_screen = 0,
1006 .attributes = { .physicalWidth = w,
1007 .physicalHeight = h,
1008 .orientation =
1009 ORIENTATION_LANDSCAPE,
1010 .desktopScaleFactor = 100,
1011 .deviceScaleFactor = 100 } };
1012 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_MonitorDefArray, 0,
1013 &primary))
1014 ret = STATE_RUN_FAILED;
1015 else if (!freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount, 1))
1016 ret = STATE_RUN_FAILED;
1017 }
1018 if (state_run_failed(ret))
1019 {
1020 }
1021 else if (!display_convert_rdp_monitor_to_monitor_def(
1022 settings->MonitorCount, settings->MonitorDefArray, &monitors))
1023 {
1024 ret = STATE_RUN_FAILED;
1025 }
1026 else if (!freerdp_display_send_monitor_layout(rdp->context, settings->MonitorCount,
1027 monitors))
1028 {
1029 ret = STATE_RUN_FAILED;
1030 }
1031 else
1032 ret = STATE_RUN_SUCCESS;
1033 free(monitors);
1034
1035 const size_t len = Stream_GetRemainingLength(s);
1036 if (!state_run_failed(ret) && (len > 0))
1037 ret = STATE_RUN_CONTINUE;
1038 }
1039 else
1040 {
1041 const size_t len = Stream_GetRemainingLength(s);
1042 if (len > 0)
1043 ret = STATE_RUN_CONTINUE;
1044 else
1045 ret = STATE_RUN_SUCCESS;
1046 }
1047 if (state_run_success(ret))
1048 {
1049 if (!rdp_server_transition_to_state(
1050 rdp, CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE))
1051 ret = STATE_RUN_FAILED;
1052 }
1053 break;
1054
1055 case CONNECTION_STATE_CAPABILITIES_EXCHANGE_CONFIRM_ACTIVE:
1060 ret = peer_recv_pdu(client, s);
1061 break;
1062
1063 case CONNECTION_STATE_FINALIZATION_SYNC:
1064 ret = peer_recv_pdu(client, s);
1065 if (rdp_finalize_is_flag_set(rdp, FINALIZE_CS_SYNCHRONIZE_PDU))
1066 {
1067 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_COOPERATE))
1068 ret = STATE_RUN_FAILED;
1069 }
1070 else
1071 ret = peer_unexpected_client_message(rdp, FINALIZE_CS_SYNCHRONIZE_PDU);
1072 break;
1073 case CONNECTION_STATE_FINALIZATION_COOPERATE:
1074 ret = peer_recv_pdu(client, s);
1075 if (rdp_finalize_is_flag_set(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU))
1076 {
1077 if (!rdp_server_transition_to_state(rdp,
1078 CONNECTION_STATE_FINALIZATION_REQUEST_CONTROL))
1079 ret = STATE_RUN_FAILED;
1080 }
1081 else
1082 ret = peer_unexpected_client_message(rdp, FINALIZE_CS_CONTROL_COOPERATE_PDU);
1083 break;
1084 case CONNECTION_STATE_FINALIZATION_REQUEST_CONTROL:
1085 ret = peer_recv_pdu(client, s);
1086 if (rdp_finalize_is_flag_set(rdp, FINALIZE_CS_CONTROL_REQUEST_PDU))
1087 {
1088 if (!rdp_send_server_control_granted_pdu(rdp))
1089 ret = STATE_RUN_FAILED;
1090 else if (!rdp_server_transition_to_state(
1091 rdp, CONNECTION_STATE_FINALIZATION_PERSISTENT_KEY_LIST))
1092 ret = STATE_RUN_FAILED;
1093 }
1094 else
1095 ret = peer_unexpected_client_message(rdp, FINALIZE_CS_CONTROL_REQUEST_PDU);
1096 break;
1097 case CONNECTION_STATE_FINALIZATION_PERSISTENT_KEY_LIST:
1098 if (freerdp_settings_get_bool(settings, FreeRDP_BitmapCachePersistEnabled) &&
1099 !rdp_finalize_is_flag_set(rdp, FINALIZE_DEACTIVATE_REACTIVATE))
1100 {
1101 ret = peer_recv_pdu(client, s);
1102
1103 if (rdp_finalize_is_flag_set(rdp, FINALIZE_CS_PERSISTENT_KEY_LIST_PDU))
1104 {
1105 if (!rdp_server_transition_to_state(rdp,
1106 CONNECTION_STATE_FINALIZATION_FONT_LIST))
1107 ret = STATE_RUN_FAILED;
1108 }
1109 else
1110 ret = peer_unexpected_client_message(rdp,
1111 CONNECTION_STATE_FINALIZATION_FONT_LIST);
1112 }
1113 else
1114 {
1115 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_FINALIZATION_FONT_LIST))
1116 ret = STATE_RUN_FAILED;
1117 else
1118 ret = STATE_RUN_CONTINUE;
1119 }
1120 break;
1121 case CONNECTION_STATE_FINALIZATION_FONT_LIST:
1122 ret = peer_recv_pdu(client, s);
1123 if (state_run_success(ret))
1124 {
1125 if (rdp_finalize_is_flag_set(rdp, FINALIZE_CS_FONT_LIST_PDU))
1126 {
1127 if (!rdp_server_transition_to_state(rdp, CONNECTION_STATE_ACTIVE))
1128 ret = STATE_RUN_FAILED;
1129 else
1130 {
1131 update_reset_state(rdp->update);
1132 ret = STATE_RUN_CONTINUE;
1133 }
1134 }
1135 else
1136 ret = peer_unexpected_client_message(rdp, FINALIZE_CS_FONT_LIST_PDU);
1137 }
1138 break;
1139
1140 case CONNECTION_STATE_ACTIVE:
1141 ret = rdp_peer_handle_state_active(client);
1142 if (ret >= STATE_RUN_ACTIVE)
1143 ret = peer_recv_pdu(client, s);
1144 break;
1145
1146 /* States that must not happen in server state machine */
1147 case CONNECTION_STATE_FINALIZATION_CLIENT_SYNC:
1148 case CONNECTION_STATE_FINALIZATION_CLIENT_COOPERATE:
1149 case CONNECTION_STATE_FINALIZATION_CLIENT_GRANTED_CONTROL:
1150 case CONNECTION_STATE_FINALIZATION_CLIENT_FONT_MAP:
1151 default:
1152 WLog_ERR(TAG, "%s state %" PRId32, rdp_get_state_string(rdp),
1153 WINPR_CXX_COMPAT_CAST(int32_t, rdp_get_state(rdp)));
1154 break;
1155 }
1156
1157 return ret;
1158}
1159
1160static state_run_t peer_recv_callback(rdpTransport* transport, wStream* s, void* extra)
1161{
1162 char buffer[64] = { 0 };
1163 state_run_t rc = STATE_RUN_FAILED;
1164 const size_t start = Stream_GetPosition(s);
1165 const rdpContext* context = transport_get_context(transport);
1166 DWORD level = WLOG_TRACE;
1167 static wLog* log = NULL;
1168 if (!log)
1169 log = WLog_Get(TAG);
1170
1171 WINPR_ASSERT(context);
1172 do
1173 {
1174 const rdpRdp* rdp = context->rdp;
1175 const char* old = rdp_get_state_string(rdp);
1176
1177 if (rc == STATE_RUN_TRY_AGAIN)
1178 Stream_SetPosition(s, start);
1179 rc = peer_recv_callback_internal(transport, s, extra);
1180
1181 const size_t len = Stream_GetRemainingLength(s);
1182 if ((len > 0) && !state_run_continue(rc))
1183 level = WLOG_WARN;
1184 WLog_Print(log, level,
1185 "(server)[%s -> %s] current return %s [%" PRIuz " bytes not processed]", old,
1186 rdp_get_state_string(rdp), state_run_result_string(rc, buffer, sizeof(buffer)),
1187 len);
1188 } while (state_run_continue(rc));
1189
1190 return rc;
1191}
1192
1193static BOOL freerdp_peer_close(freerdp_peer* client)
1194{
1195 UINT32 SelectedProtocol = 0;
1196 rdpContext* context = NULL;
1197
1198 WINPR_ASSERT(client);
1199
1200 context = client->context;
1201 WINPR_ASSERT(context);
1202 WINPR_ASSERT(context->settings);
1203 WINPR_ASSERT(context->rdp);
1204
1208 SelectedProtocol = nego_get_selected_protocol(context->rdp->nego);
1209
1210 if (SelectedProtocol & PROTOCOL_FAILED_NEGO)
1211 return TRUE;
1212
1218 if (!rdp_send_deactivate_all(context->rdp))
1219 return FALSE;
1220
1221 if (freerdp_settings_get_bool(context->settings, FreeRDP_SupportErrorInfoPdu))
1222 {
1223 rdp_send_error_info(context->rdp);
1224 }
1225
1226 return mcs_send_disconnect_provider_ultimatum(context->rdp->mcs,
1227 Disconnect_Ultimatum_provider_initiated);
1228}
1229
1230static void freerdp_peer_disconnect(freerdp_peer* client)
1231{
1232 rdpTransport* transport = NULL;
1233 WINPR_ASSERT(client);
1234
1235 transport = freerdp_get_transport(client->context);
1236 transport_disconnect(transport);
1237}
1238
1239static BOOL freerdp_peer_send_channel_data(freerdp_peer* client, UINT16 channelId, const BYTE* data,
1240 size_t size)
1241{
1242 WINPR_ASSERT(client);
1243 WINPR_ASSERT(client->context);
1244 WINPR_ASSERT(client->context->rdp);
1245 return rdp_send_channel_data(client->context->rdp, channelId, data, size);
1246}
1247
1248static BOOL freerdp_peer_send_server_redirection_pdu(freerdp_peer* peer,
1249 const rdpRedirection* redirection)
1250{
1251 BOOL rc = FALSE;
1252 WINPR_ASSERT(peer);
1253 WINPR_ASSERT(peer->context);
1254
1255 UINT16 sec_flags = 0;
1256 wStream* s = rdp_send_stream_pdu_init(peer->context->rdp, &sec_flags);
1257 if (!s)
1258 return FALSE;
1259 if (!rdp_write_enhanced_security_redirection_packet(s, redirection))
1260 goto fail;
1261 if (!rdp_send_pdu(peer->context->rdp, s, PDU_TYPE_SERVER_REDIRECTION, 0, sec_flags))
1262 goto fail;
1263 rc = rdp_reset_runtime_settings(peer->context->rdp);
1264fail:
1265 Stream_Release(s);
1266 return rc;
1267}
1268
1269static BOOL freerdp_peer_send_channel_packet(freerdp_peer* client, UINT16 channelId,
1270 size_t totalSize, UINT32 flags, const BYTE* data,
1271 size_t chunkSize)
1272{
1273 WINPR_ASSERT(client);
1274 WINPR_ASSERT(client->context);
1275 WINPR_ASSERT(client->context->rdp);
1276 return rdp_channel_send_packet(client->context->rdp, channelId, totalSize, flags, data,
1277 chunkSize);
1278}
1279
1280static BOOL freerdp_peer_is_write_blocked(freerdp_peer* peer)
1281{
1282 rdpTransport* transport = NULL;
1283 WINPR_ASSERT(peer);
1284 WINPR_ASSERT(peer->context);
1285 WINPR_ASSERT(peer->context->rdp);
1286 WINPR_ASSERT(peer->context->rdp->transport);
1287 transport = peer->context->rdp->transport;
1288 return transport_is_write_blocked(transport);
1289}
1290
1291static int freerdp_peer_drain_output_buffer(freerdp_peer* peer)
1292{
1293 rdpTransport* transport = NULL;
1294 WINPR_ASSERT(peer);
1295 WINPR_ASSERT(peer->context);
1296 WINPR_ASSERT(peer->context->rdp);
1297 WINPR_ASSERT(peer->context->rdp->transport);
1298 transport = peer->context->rdp->transport;
1299 return transport_drain_output_buffer(transport);
1300}
1301
1302static BOOL freerdp_peer_has_more_to_read(freerdp_peer* peer)
1303{
1304 WINPR_ASSERT(peer);
1305 WINPR_ASSERT(peer->context);
1306 WINPR_ASSERT(peer->context->rdp);
1307 return transport_have_more_bytes_to_read(peer->context->rdp->transport);
1308}
1309
1310static LicenseCallbackResult freerdp_peer_nolicense(freerdp_peer* peer,
1311 WINPR_ATTR_UNUSED wStream* s)
1312{
1313 rdpRdp* rdp = NULL;
1314
1315 WINPR_ASSERT(peer);
1316 WINPR_ASSERT(peer->context);
1317
1318 rdp = peer->context->rdp;
1319
1320 if (!license_send_valid_client_error_packet(rdp))
1321 {
1322 WLog_ERR(TAG, "freerdp_peer_nolicense: license_send_valid_client_error_packet() failed");
1323 return LICENSE_CB_ABORT;
1324 }
1325
1326 return LICENSE_CB_COMPLETED;
1327}
1328
1329BOOL freerdp_peer_context_new(freerdp_peer* client)
1330{
1331 return freerdp_peer_context_new_ex(client, NULL);
1332}
1333
1334void freerdp_peer_context_free(freerdp_peer* client)
1335{
1336 if (!client)
1337 return;
1338
1339 IFCALL(client->ContextFree, client, client->context);
1340
1341 if (client->context)
1342 {
1343 rdpContext* ctx = client->context;
1344
1345 (void)CloseHandle(ctx->channelErrorEvent);
1346 ctx->channelErrorEvent = NULL;
1347 free(ctx->errorDescription);
1348 ctx->errorDescription = NULL;
1349 rdp_free(ctx->rdp);
1350 ctx->rdp = NULL;
1351 metrics_free(ctx->metrics);
1352 ctx->metrics = NULL;
1353 stream_dump_free(ctx->dump);
1354 ctx->dump = NULL;
1355 free(ctx);
1356 }
1357 client->context = NULL;
1358}
1359
1360static const char* os_major_type_to_string(UINT16 osMajorType)
1361{
1362 switch (osMajorType)
1363 {
1364 case OSMAJORTYPE_UNSPECIFIED:
1365 return "Unspecified platform";
1366 case OSMAJORTYPE_WINDOWS:
1367 return "Windows platform";
1368 case OSMAJORTYPE_OS2:
1369 return "OS/2 platform";
1370 case OSMAJORTYPE_MACINTOSH:
1371 return "Macintosh platform";
1372 case OSMAJORTYPE_UNIX:
1373 return "UNIX platform";
1374 case OSMAJORTYPE_IOS:
1375 return "iOS platform";
1376 case OSMAJORTYPE_OSX:
1377 return "OS X platform";
1378 case OSMAJORTYPE_ANDROID:
1379 return "Android platform";
1380 case OSMAJORTYPE_CHROME_OS:
1381 return "Chrome OS platform";
1382 default:
1383 break;
1384 }
1385
1386 return "Unknown platform";
1387}
1388
1389const char* freerdp_peer_os_major_type_string(freerdp_peer* client)
1390{
1391 WINPR_ASSERT(client);
1392
1393 rdpContext* context = client->context;
1394 WINPR_ASSERT(context);
1395 WINPR_ASSERT(context->settings);
1396
1397 const UINT32 osMajorType = freerdp_settings_get_uint32(context->settings, FreeRDP_OsMajorType);
1398 WINPR_ASSERT(osMajorType <= UINT16_MAX);
1399 return os_major_type_to_string((UINT16)osMajorType);
1400}
1401
1402static const char* os_minor_type_to_string(UINT16 osMinorType)
1403{
1404 switch (osMinorType)
1405 {
1406 case OSMINORTYPE_UNSPECIFIED:
1407 return "Unspecified version";
1408 case OSMINORTYPE_WINDOWS_31X:
1409 return "Windows 3.1x";
1410 case OSMINORTYPE_WINDOWS_95:
1411 return "Windows 95";
1412 case OSMINORTYPE_WINDOWS_NT:
1413 return "Windows NT";
1414 case OSMINORTYPE_OS2_V21:
1415 return "OS/2 2.1";
1416 case OSMINORTYPE_POWER_PC:
1417 return "PowerPC";
1418 case OSMINORTYPE_MACINTOSH:
1419 return "Macintosh";
1420 case OSMINORTYPE_NATIVE_XSERVER:
1421 return "Native X Server";
1422 case OSMINORTYPE_PSEUDO_XSERVER:
1423 return "Pseudo X Server";
1424 case OSMINORTYPE_WINDOWS_RT:
1425 return "Windows RT";
1426 default:
1427 break;
1428 }
1429
1430 return "Unknown version";
1431}
1432
1433const char* freerdp_peer_os_minor_type_string(freerdp_peer* client)
1434{
1435 WINPR_ASSERT(client);
1436
1437 rdpContext* context = client->context;
1438 WINPR_ASSERT(context);
1439 WINPR_ASSERT(context->settings);
1440
1441 const UINT32 osMinorType = freerdp_settings_get_uint32(context->settings, FreeRDP_OsMinorType);
1442 WINPR_ASSERT(osMinorType <= UINT16_MAX);
1443 return os_minor_type_to_string((UINT16)osMinorType);
1444}
1445
1446freerdp_peer* freerdp_peer_new(int sockfd)
1447{
1448 freerdp_peer* client = (freerdp_peer*)calloc(1, sizeof(freerdp_peer));
1449
1450 if (!client)
1451 return NULL;
1452
1453 if (sockfd >= 0)
1454 {
1455 (void)freerdp_tcp_set_nodelay(WLog_Get(TAG), WLOG_DEBUG, sockfd);
1456 }
1457
1458 if (client)
1459 {
1460 client->sockfd = sockfd;
1461 client->ContextSize = sizeof(rdpContext);
1462 client->Initialize = freerdp_peer_initialize;
1463#if defined(WITH_FREERDP_DEPRECATED)
1464 client->GetFileDescriptor = freerdp_peer_get_fds;
1465#endif
1466 client->GetEventHandle = freerdp_peer_get_event_handle;
1467 client->GetEventHandles = freerdp_peer_get_event_handles;
1468 client->CheckFileDescriptor = freerdp_peer_check_fds;
1469 client->Close = freerdp_peer_close;
1470 client->Disconnect = freerdp_peer_disconnect;
1471 client->SendChannelData = freerdp_peer_send_channel_data;
1472 client->SendChannelPacket = freerdp_peer_send_channel_packet;
1473 client->SendServerRedirection = freerdp_peer_send_server_redirection_pdu;
1474 client->IsWriteBlocked = freerdp_peer_is_write_blocked;
1475 client->DrainOutputBuffer = freerdp_peer_drain_output_buffer;
1476 client->HasMoreToRead = freerdp_peer_has_more_to_read;
1477 client->VirtualChannelOpen = freerdp_peer_virtual_channel_open;
1478 client->VirtualChannelClose = freerdp_peer_virtual_channel_close;
1479 client->VirtualChannelWrite = freerdp_peer_virtual_channel_write;
1480 client->VirtualChannelRead = NULL; /* must be defined by server application */
1481 client->VirtualChannelGetData = freerdp_peer_virtual_channel_get_data;
1482 client->VirtualChannelSetData = freerdp_peer_virtual_channel_set_data;
1483 client->SetState = freerdp_peer_set_state;
1484 }
1485
1486 return client;
1487}
1488
1489void freerdp_peer_free(freerdp_peer* client)
1490{
1491 if (!client)
1492 return;
1493
1494 sspi_FreeAuthIdentity(&client->identity);
1495 if (client->sockfd >= 0)
1496 closesocket((SOCKET)client->sockfd);
1497 free(client);
1498}
1499
1500static BOOL freerdp_peer_transport_setup(freerdp_peer* client)
1501{
1502 rdpRdp* rdp = NULL;
1503
1504 WINPR_ASSERT(client);
1505 WINPR_ASSERT(client->context);
1506
1507 rdp = client->context->rdp;
1508 WINPR_ASSERT(rdp);
1509
1510 if (!transport_attach(rdp->transport, client->sockfd))
1511 return FALSE;
1512 client->sockfd = -1;
1513
1514 if (!transport_set_recv_callbacks(rdp->transport, peer_recv_callback, client))
1515 return FALSE;
1516
1517 if (!transport_set_blocking_mode(rdp->transport, FALSE))
1518 return FALSE;
1519
1520 return TRUE;
1521}
1522
1523BOOL freerdp_peer_context_new_ex(freerdp_peer* client, const rdpSettings* settings)
1524{
1525 rdpRdp* rdp = NULL;
1526 rdpContext* context = NULL;
1527 BOOL ret = TRUE;
1528
1529 if (!client)
1530 return FALSE;
1531
1532 WINPR_ASSERT(client->ContextSize >= sizeof(rdpContext));
1533 if (!(context = (rdpContext*)calloc(1, client->ContextSize)))
1534 goto fail;
1535
1536 client->context = context;
1537 context->peer = client;
1538 context->ServerMode = TRUE;
1539 context->log = WLog_Get(TAG);
1540 if (!context->log)
1541 goto fail;
1542
1543 if (settings)
1544 {
1545 context->settings = freerdp_settings_clone(settings);
1546 if (!context->settings)
1547 goto fail;
1548 }
1549
1550 context->dump = stream_dump_new();
1551 if (!context->dump)
1552 goto fail;
1553 if (!(context->metrics = metrics_new(context)))
1554 goto fail;
1555
1556 if (!(rdp = rdp_new(context)))
1557 goto fail;
1558
1559 rdp_log_build_warnings(rdp);
1560
1561#if defined(WITH_FREERDP_DEPRECATED)
1562 client->update = rdp->update;
1563 client->settings = rdp->settings;
1564 client->autodetect = rdp->autodetect;
1565#endif
1566 context->rdp = rdp;
1567 context->input = rdp->input;
1568 context->update = rdp->update;
1569 context->settings = rdp->settings;
1570 context->autodetect = rdp->autodetect;
1571 update_register_server_callbacks(rdp->update);
1572 autodetect_register_server_callbacks(rdp->autodetect);
1573
1574 if (!(context->channelErrorEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
1575 {
1576 WLog_ERR(TAG, "CreateEvent failed!");
1577 goto fail;
1578 }
1579
1580 if (!(context->errorDescription = calloc(1, 500)))
1581 {
1582 WLog_ERR(TAG, "calloc failed!");
1583 goto fail;
1584 }
1585
1586 if (!freerdp_peer_transport_setup(client))
1587 goto fail;
1588
1589 client->IsWriteBlocked = freerdp_peer_is_write_blocked;
1590 client->DrainOutputBuffer = freerdp_peer_drain_output_buffer;
1591 client->HasMoreToRead = freerdp_peer_has_more_to_read;
1592 client->LicenseCallback = freerdp_peer_nolicense;
1593 IFCALLRET(client->ContextNew, ret, client, client->context);
1594
1595 if (!ret)
1596 goto fail;
1597 return TRUE;
1598
1599fail:
1600 WLog_ERR(TAG, "ContextNew callback failed");
1601 freerdp_peer_context_free(client);
1602 return FALSE;
1603}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_clone
FREERDP_API rdpSettings * freerdp_settings_clone(const rdpSettings *settings)
Creates a deep copy of settings.
Definition core/settings.c:1531
freerdp_settings_get_pointer
FREERDP_API const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
Definition common/settings.c:1430
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.
MONITOR_DEF
Definition settings_types.h:405
rdpMonitor
Definition settings_types.h:423
SEC_WINNT_AUTH_IDENTITY_INFO
Definition include/winpr/sspi.h:783