FreeRDP
Loading...
Searching...
No Matches
SDL2/sdl_freerdp.cpp
1
20#include <memory>
21#include <mutex>
22#include <iostream>
23
24#include <freerdp/config.h>
25
26#include <cerrno>
27#include <cstdio>
28#include <cstring>
29
30#include <freerdp/freerdp.h>
31#include <freerdp/constants.h>
32#include <freerdp/gdi/gdi.h>
33#include <freerdp/streamdump.h>
34#include <freerdp/utils/signal.h>
35
36#include <freerdp/client/file.h>
37#include <freerdp/client/cmdline.h>
38#include <freerdp/client/cliprdr.h>
39#include <freerdp/client/channels.h>
40#include <freerdp/channels/channels.h>
41
42#include <winpr/crt.h>
43#include <winpr/config.h>
44#include <winpr/assert.h>
45#include <winpr/synch.h>
46#include <freerdp/log.h>
47
48#include <SDL.h>
49#include <SDL_hints.h>
50#include <SDL_video.h>
51
52#include "sdl_channels.hpp"
53#include "sdl_freerdp.hpp"
54#include "sdl_utils.hpp"
55#include "sdl_disp.hpp"
56#include "sdl_monitor.hpp"
57#include "sdl_kbd.hpp"
58#include "sdl_touch.hpp"
59#include "sdl_pointer.hpp"
60#include "sdl_prefs.hpp"
61#include "dialogs/sdl_dialogs.hpp"
62#include "scoped_guard.hpp"
63
64#include <sdl_config.hpp>
65
66#if defined(WITH_WEBVIEW)
67#include <aad/sdl_webview.hpp>
68#endif
69
70#define SDL_TAG CLIENT_TAG("SDL")
71
72enum SDL_EXIT_CODE
73{
74 /* section 0-15: protocol-independent codes */
75 SDL_EXIT_SUCCESS = 0,
76 SDL_EXIT_DISCONNECT = 1,
77 SDL_EXIT_LOGOFF = 2,
78 SDL_EXIT_IDLE_TIMEOUT = 3,
79 SDL_EXIT_LOGON_TIMEOUT = 4,
80 SDL_EXIT_CONN_REPLACED = 5,
81 SDL_EXIT_OUT_OF_MEMORY = 6,
82 SDL_EXIT_CONN_DENIED = 7,
83 SDL_EXIT_CONN_DENIED_FIPS = 8,
84 SDL_EXIT_USER_PRIVILEGES = 9,
85 SDL_EXIT_FRESH_CREDENTIALS_REQUIRED = 10,
86 SDL_EXIT_DISCONNECT_BY_USER = 11,
87
88 /* section 16-31: license error set */
89 SDL_EXIT_LICENSE_INTERNAL = 16,
90 SDL_EXIT_LICENSE_NO_LICENSE_SERVER = 17,
91 SDL_EXIT_LICENSE_NO_LICENSE = 18,
92 SDL_EXIT_LICENSE_BAD_CLIENT_MSG = 19,
93 SDL_EXIT_LICENSE_HWID_DOESNT_MATCH = 20,
94 SDL_EXIT_LICENSE_BAD_CLIENT = 21,
95 SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL = 22,
96 SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL = 23,
97 SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION = 24,
98 SDL_EXIT_LICENSE_CANT_UPGRADE = 25,
99 SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS = 26,
100
101 /* section 32-127: RDP protocol error set */
102 SDL_EXIT_RDP = 32,
103
104 /* section 128-254: xfreerdp specific exit codes */
105 SDL_EXIT_PARSE_ARGUMENTS = 128,
106 SDL_EXIT_MEMORY = 129,
107 SDL_EXIT_PROTOCOL = 130,
108 SDL_EXIT_CONN_FAILED = 131,
109 SDL_EXIT_AUTH_FAILURE = 132,
110 SDL_EXIT_NEGO_FAILURE = 133,
111 SDL_EXIT_LOGON_FAILURE = 134,
112 SDL_EXIT_ACCOUNT_LOCKED_OUT = 135,
113 SDL_EXIT_PRE_CONNECT_FAILED = 136,
114 SDL_EXIT_CONNECT_UNDEFINED = 137,
115 SDL_EXIT_POST_CONNECT_FAILED = 138,
116 SDL_EXIT_DNS_ERROR = 139,
117 SDL_EXIT_DNS_NAME_NOT_FOUND = 140,
118 SDL_EXIT_CONNECT_FAILED = 141,
119 SDL_EXIT_MCS_CONNECT_INITIAL_ERROR = 142,
120 SDL_EXIT_TLS_CONNECT_FAILED = 143,
121 SDL_EXIT_INSUFFICIENT_PRIVILEGES = 144,
122 SDL_EXIT_CONNECT_CANCELLED = 145,
123
124 SDL_EXIT_CONNECT_TRANSPORT_FAILED = 147,
125 SDL_EXIT_CONNECT_PASSWORD_EXPIRED = 148,
126 SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE = 149,
127 SDL_EXIT_CONNECT_KDC_UNREACHABLE = 150,
128 SDL_EXIT_CONNECT_ACCOUNT_DISABLED = 151,
129 SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED = 152,
130 SDL_EXIT_CONNECT_CLIENT_REVOKED = 153,
131 SDL_EXIT_CONNECT_WRONG_PASSWORD = 154,
132 SDL_EXIT_CONNECT_ACCESS_DENIED = 155,
133 SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION = 156,
134 SDL_EXIT_CONNECT_ACCOUNT_EXPIRED = 157,
135 SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED = 158,
136 SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS = 159,
137
138 SDL_EXIT_UNKNOWN = 255,
139};
140
141struct sdl_exit_code_map_t
142{
143 UINT32 error;
144 int code;
145 const char* code_tag;
146};
147
148#define ENTRY(x, y) { x, y, #y }
149static const struct sdl_exit_code_map_t sdl_exit_code_map[] = {
150 ENTRY(FREERDP_ERROR_SUCCESS, SDL_EXIT_SUCCESS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_DISCONNECT),
151 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGOFF), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_IDLE_TIMEOUT),
152 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGON_TIMEOUT),
153 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_REPLACED),
154 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_OUT_OF_MEMORY),
155 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED),
156 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED_FIPS),
157 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_USER_PRIVILEGES),
158 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_FRESH_CREDENTIALS_REQUIRED),
159 ENTRY(ERRINFO_LOGOFF_BY_USER, SDL_EXIT_DISCONNECT_BY_USER),
160 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_UNKNOWN),
161
162 /* section 16-31: license error set */
163 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_INTERNAL),
164 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE_SERVER),
165 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE),
166 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_MSG),
167 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_HWID_DOESNT_MATCH),
168 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT),
169 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL),
170 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL),
171 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION),
172 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
173 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS),
174 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
175
176 /* section 32-127: RDP protocol error set */
177 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_RDP),
178
179 /* section 128-254: xfreerdp specific exit codes */
180 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PARSE_ARGUMENTS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_MEMORY),
181 ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PROTOCOL), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_FAILED),
182
183 ENTRY(FREERDP_ERROR_AUTHENTICATION_FAILED, SDL_EXIT_AUTH_FAILURE),
184 ENTRY(FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED, SDL_EXIT_NEGO_FAILURE),
185 ENTRY(FREERDP_ERROR_CONNECT_LOGON_FAILURE, SDL_EXIT_LOGON_FAILURE),
186 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_LOCKED_OUT, SDL_EXIT_ACCOUNT_LOCKED_OUT),
187 ENTRY(FREERDP_ERROR_PRE_CONNECT_FAILED, SDL_EXIT_PRE_CONNECT_FAILED),
188 ENTRY(FREERDP_ERROR_CONNECT_UNDEFINED, SDL_EXIT_CONNECT_UNDEFINED),
189 ENTRY(FREERDP_ERROR_POST_CONNECT_FAILED, SDL_EXIT_POST_CONNECT_FAILED),
190 ENTRY(FREERDP_ERROR_DNS_ERROR, SDL_EXIT_DNS_ERROR),
191 ENTRY(FREERDP_ERROR_DNS_NAME_NOT_FOUND, SDL_EXIT_DNS_NAME_NOT_FOUND),
192 ENTRY(FREERDP_ERROR_CONNECT_FAILED, SDL_EXIT_CONNECT_FAILED),
193 ENTRY(FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR, SDL_EXIT_MCS_CONNECT_INITIAL_ERROR),
194 ENTRY(FREERDP_ERROR_TLS_CONNECT_FAILED, SDL_EXIT_TLS_CONNECT_FAILED),
195 ENTRY(FREERDP_ERROR_INSUFFICIENT_PRIVILEGES, SDL_EXIT_INSUFFICIENT_PRIVILEGES),
196 ENTRY(FREERDP_ERROR_CONNECT_CANCELLED, SDL_EXIT_CONNECT_CANCELLED),
197 ENTRY(FREERDP_ERROR_CONNECT_TRANSPORT_FAILED, SDL_EXIT_CONNECT_TRANSPORT_FAILED),
198 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_EXPIRED, SDL_EXIT_CONNECT_PASSWORD_EXPIRED),
199 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_MUST_CHANGE, SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE),
200 ENTRY(FREERDP_ERROR_CONNECT_KDC_UNREACHABLE, SDL_EXIT_CONNECT_KDC_UNREACHABLE),
201 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_DISABLED, SDL_EXIT_CONNECT_ACCOUNT_DISABLED),
202 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_CERTAINLY_EXPIRED,
203 SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED),
204 ENTRY(FREERDP_ERROR_CONNECT_CLIENT_REVOKED, SDL_EXIT_CONNECT_CLIENT_REVOKED),
205 ENTRY(FREERDP_ERROR_CONNECT_WRONG_PASSWORD, SDL_EXIT_CONNECT_WRONG_PASSWORD),
206 ENTRY(FREERDP_ERROR_CONNECT_ACCESS_DENIED, SDL_EXIT_CONNECT_ACCESS_DENIED),
207 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_RESTRICTION, SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION),
208 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_EXPIRED, SDL_EXIT_CONNECT_ACCOUNT_EXPIRED),
209 ENTRY(FREERDP_ERROR_CONNECT_LOGON_TYPE_NOT_GRANTED, SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED),
210 ENTRY(FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS,
211 SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS)
212};
213
214static const struct sdl_exit_code_map_t* sdl_map_entry_by_code(int exit_code)
215{
216 for (const auto& x : sdl_exit_code_map)
217 {
218 const struct sdl_exit_code_map_t* cur = &x;
219 if (cur->code == exit_code)
220 return cur;
221 }
222 return nullptr;
223}
224
225static void sdl_hide_connection_dialog(SdlContext* sdl)
226{
227 WINPR_ASSERT(sdl);
228 std::lock_guard<CriticalSection> lock(sdl->critical);
229 if (sdl->connection_dialog)
230 sdl->connection_dialog->hide();
231}
232
233static const struct sdl_exit_code_map_t* sdl_map_entry_by_error(UINT32 error)
234{
235 for (const auto& x : sdl_exit_code_map)
236 {
237 const struct sdl_exit_code_map_t* cur = &x;
238 if (cur->error == static_cast<uint32_t>(error))
239 return cur;
240 }
241 return nullptr;
242}
243
244static int sdl_map_error_to_exit_code(UINT32 error)
245{
246 const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
247 if (entry)
248 return entry->code;
249
250 return SDL_EXIT_CONN_FAILED;
251}
252
253static const char* sdl_map_error_to_code_tag(UINT32 error)
254{
255 const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
256 if (entry)
257 return entry->code_tag;
258 return nullptr;
259}
260
261static const char* sdl_map_to_code_tag(int code)
262{
263 const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_code(code);
264 if (entry)
265 return entry->code_tag;
266 return nullptr;
267}
268
269static int error_info_to_error(freerdp* instance, DWORD* pcode, char** msg, size_t* len)
270{
271 const DWORD code = freerdp_error_info(instance);
272 const char* name = freerdp_get_error_info_name(code);
273 const char* str = freerdp_get_error_info_string(code);
274 const int exit_code = sdl_map_error_to_exit_code(code);
275
276 winpr_asprintf(msg, len, "Terminate with %s due to ERROR_INFO %s [0x%08" PRIx32 "]: %s",
277 sdl_map_error_to_code_tag(code), name, code, str);
278 WLog_DBG(SDL_TAG, "%s", *msg);
279 if (pcode)
280 *pcode = code;
281 return exit_code;
282}
283
284/* This function is called whenever a new frame starts.
285 * It can be used to reset invalidated areas. */
286static BOOL sdl_begin_paint(rdpContext* context)
287{
288 auto sdl = get_context(context);
289
290 WINPR_ASSERT(sdl);
291
292 HANDLE handles[] = { sdl->update_complete.handle(), freerdp_abort_event(context) };
293 const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
294 switch (status)
295 {
296 case WAIT_OBJECT_0:
297 break;
298 default:
299 return FALSE;
300 }
301 sdl->update_complete.clear();
302
303 auto gdi = context->gdi;
304 WINPR_ASSERT(gdi);
305 WINPR_ASSERT(gdi->primary);
306
307 HGDI_DC hdc = gdi->primary->hdc;
308 WINPR_ASSERT(hdc);
309 if (!hdc->hwnd)
310 return TRUE;
311
312 HGDI_WND hwnd = hdc->hwnd;
313 WINPR_ASSERT(hwnd->invalid);
314 hwnd->invalid->null = TRUE;
315 hwnd->ninvalid = 0;
316
317 return TRUE;
318}
319
320static BOOL sdl_redraw(SdlContext* sdl)
321{
322 WINPR_ASSERT(sdl);
323
324 auto gdi = sdl->context()->gdi;
325 return gdi_send_suppress_output(gdi, FALSE);
326}
327
328class SdlEventUpdateTriggerGuard
329{
330 private:
331 SdlContext* _sdl;
332
333 public:
334 explicit SdlEventUpdateTriggerGuard(SdlContext* sdl) : _sdl(sdl)
335 {
336 }
337 ~SdlEventUpdateTriggerGuard()
338 {
339 _sdl->update_complete.set();
340 }
341 SdlEventUpdateTriggerGuard(const SdlEventUpdateTriggerGuard&) = delete;
342 SdlEventUpdateTriggerGuard(SdlEventUpdateTriggerGuard&&) = delete;
343 SdlEventUpdateTriggerGuard& operator=(const SdlEventUpdateTriggerGuard&) = delete;
344 SdlEventUpdateTriggerGuard& operator=(SdlEventUpdateTriggerGuard&&) = delete;
345};
346
347static bool sdl_draw_to_window_rect([[maybe_unused]] SdlContext* sdl, SdlWindow& window,
348 SDL_Surface* surface, SDL_Point offset, SDL_Rect srcRect)
349{
350 SDL_Rect dstRect = { offset.x + srcRect.x, offset.y + srcRect.y, srcRect.w, srcRect.h };
351 return window.blit(surface, srcRect, dstRect);
352}
353
354static bool sdl_draw_to_window_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
355 SDL_Point offset, const std::vector<SDL_Rect>& rects = {})
356{
357 if (rects.empty())
358 {
359 return sdl_draw_to_window_rect(sdl, window, surface, offset,
360 { 0, 0, surface->w, surface->h });
361 }
362 for (auto& srcRect : rects)
363 {
364 if (!sdl_draw_to_window_rect(sdl, window, surface, offset, srcRect))
365 return false;
366 }
367 return true;
368}
369
370static bool sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
371 SDL_Rect srcRect)
372{
373 SDL_Rect dstRect = srcRect;
374 sdl_scale_coordinates(sdl, window.id(), &dstRect.x, &dstRect.y, FALSE, TRUE);
375 sdl_scale_coordinates(sdl, window.id(), &dstRect.w, &dstRect.h, FALSE, TRUE);
376 return window.blit(surface, srcRect, dstRect);
377}
378
379static BOOL sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
380 const std::vector<SDL_Rect>& rects = {})
381{
382 if (rects.empty())
383 {
384 return sdl_draw_to_window_scaled_rect(sdl, window, surface,
385 { 0, 0, surface->w, surface->h });
386 }
387 for (const auto& srcRect : rects)
388 {
389 if (!sdl_draw_to_window_scaled_rect(sdl, window, surface, srcRect))
390 return FALSE;
391 }
392 return TRUE;
393}
394
395static BOOL sdl_draw_to_window(SdlContext* sdl, SdlWindow& window,
396 const std::vector<SDL_Rect>& rects = {})
397{
398 WINPR_ASSERT(sdl);
399
400 auto context = sdl->context();
401 auto gdi = context->gdi;
402
403 auto size = window.rect();
404
405 if (!freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing))
406 {
407 if (gdi->width < size.w)
408 {
409 window.setOffsetX((size.w - gdi->width) / 2);
410 }
411 if (gdi->height < size.h)
412 {
413 window.setOffsetY((size.h - gdi->height) / 2);
414 }
415
416 auto surface = sdl->primary.get();
417 if (!sdl_draw_to_window_rect(sdl, window, surface, { window.offsetX(), window.offsetY() },
418 rects))
419 return FALSE;
420 }
421 else
422 {
423 if (!sdl_draw_to_window_scaled_rect(sdl, window, sdl->primary.get(), rects))
424 return FALSE;
425 }
426 window.updateSurface();
427 return TRUE;
428}
429
430static BOOL sdl_draw_to_window(SdlContext* sdl, std::map<Uint32, SdlWindow>& windows,
431 const std::vector<SDL_Rect>& rects = {})
432{
433 for (auto& window : windows)
434 {
435 if (!sdl_draw_to_window(sdl, window.second, rects))
436 return FALSE;
437 }
438
439 return TRUE;
440}
441
442static BOOL sdl_end_paint_process(rdpContext* context)
443{
444 auto sdl = get_context(context);
445
446 WINPR_ASSERT(context);
447
448 SdlEventUpdateTriggerGuard guard(sdl);
449
450 auto gdi = context->gdi;
451 WINPR_ASSERT(gdi);
452 WINPR_ASSERT(gdi->primary);
453
454 HGDI_DC hdc = gdi->primary->hdc;
455 WINPR_ASSERT(hdc);
456 if (!hdc->hwnd)
457 return TRUE;
458
459 HGDI_WND hwnd = hdc->hwnd;
460 WINPR_ASSERT(hwnd->invalid || (hwnd->ninvalid == 0));
461
462 if (hwnd->invalid->null)
463 return TRUE;
464
465 WINPR_ASSERT(hwnd->invalid);
466 if (gdi->suppressOutput || hwnd->invalid->null)
467 return TRUE;
468
469 const INT32 ninvalid = hwnd->ninvalid;
470 const GDI_RGN* cinvalid = hwnd->cinvalid;
471
472 if (ninvalid < 1)
473 return TRUE;
474
475 std::vector<SDL_Rect> rects;
476 for (INT32 x = 0; x < ninvalid; x++)
477 {
478 auto& rgn = cinvalid[x];
479 rects.push_back({ rgn.x, rgn.y, rgn.w, rgn.h });
480 }
481
482 return sdl_draw_to_window(sdl, sdl->windows, rects);
483}
484
485/* This function is called when the library completed composing a new
486 * frame. Read out the changed areas and blit them to your output device.
487 * The image buffer will have the format specified by gdi_init
488 */
489static BOOL sdl_end_paint(rdpContext* context)
490{
491 auto sdl = get_context(context);
492 WINPR_ASSERT(sdl);
493
494 std::lock_guard<CriticalSection> lock(sdl->critical);
495 const BOOL rc = sdl_push_user_event(SDL_USEREVENT_UPDATE, context);
496
497 return rc;
498}
499
500static void sdl_destroy_primary(SdlContext* sdl)
501{
502 if (!sdl)
503 return;
504 sdl->primary.reset();
505 sdl->primary_format.reset();
506}
507
508/* Create a SDL surface from the GDI buffer */
509static BOOL sdl_create_primary(SdlContext* sdl)
510{
511 rdpGdi* gdi = nullptr;
512
513 WINPR_ASSERT(sdl);
514
515 gdi = sdl->context()->gdi;
516 WINPR_ASSERT(gdi);
517
518 sdl_destroy_primary(sdl);
519 sdl->primary = SDLSurfacePtr(
520 SDL_CreateRGBSurfaceWithFormatFrom(gdi->primary_buffer, static_cast<int>(gdi->width),
521 static_cast<int>(gdi->height),
522 static_cast<int>(FreeRDPGetBitsPerPixel(gdi->dstFormat)),
523 static_cast<int>(gdi->stride), sdl->sdl_pixel_format),
524 SDL_FreeSurface);
525 sdl->primary_format = SDLPixelFormatPtr(SDL_AllocFormat(sdl->sdl_pixel_format), SDL_FreeFormat);
526
527 if (!sdl->primary || !sdl->primary_format)
528 return FALSE;
529
530 SDL_SetSurfaceBlendMode(sdl->primary.get(), SDL_BLENDMODE_NONE);
531 SDL_FillRect(sdl->primary.get(), nullptr,
532 SDL_MapRGBA(sdl->primary_format.get(), 0, 0, 0, 0xff));
533
534 return TRUE;
535}
536
537static BOOL sdl_desktop_resize(rdpContext* context)
538{
539 rdpGdi* gdi = nullptr;
540 rdpSettings* settings = nullptr;
541 auto sdl = get_context(context);
542
543 WINPR_ASSERT(sdl);
544 WINPR_ASSERT(context);
545
546 settings = context->settings;
547 WINPR_ASSERT(settings);
548
549 std::lock_guard<CriticalSection> lock(sdl->critical);
550 gdi = context->gdi;
551 if (!gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
552 freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
553 return FALSE;
554 return sdl_create_primary(sdl);
555}
556
557/* This function is called to output a System BEEP */
558static BOOL sdl_play_sound(rdpContext* context, const PLAY_SOUND_UPDATE* play_sound)
559{
560 /* TODO: Implement */
561 WINPR_UNUSED(context);
562 WINPR_UNUSED(play_sound);
563 return TRUE;
564}
565
566static BOOL sdl_wait_for_init(SdlContext* sdl)
567{
568 WINPR_ASSERT(sdl);
569 sdl->initialize.set();
570
571 HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
572
573 const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
574 switch (rc)
575 {
576 case WAIT_OBJECT_0:
577 return TRUE;
578 default:
579 return FALSE;
580 }
581}
582
583/* Called before a connection is established.
584 * Set all configuration options to support and load channels here. */
585static BOOL sdl_pre_connect(freerdp* instance)
586{
587 WINPR_ASSERT(instance);
588 WINPR_ASSERT(instance->context);
589
590 auto sdl = get_context(instance->context);
591
592 auto settings = instance->context->settings;
593 WINPR_ASSERT(settings);
594
595 if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
596 return FALSE;
597
598 /* Optional OS identifier sent to server */
599 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
600 return FALSE;
601 if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_SDL))
602 return FALSE;
603 /* OrderSupport is initialized at this point.
604 * Only override it if you plan to implement custom order
605 * callbacks or deactivate certain features. */
606 /* Register the channel listeners.
607 * They are required to set up / tear down channels if they are loaded. */
608 PubSub_SubscribeChannelConnected(instance->context->pubSub, sdl_OnChannelConnectedEventHandler);
609 PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
610 sdl_OnChannelDisconnectedEventHandler);
611
612 if (!freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
613 {
614 UINT32 maxWidth = 0;
615 UINT32 maxHeight = 0;
616
617 if (!sdl_wait_for_init(sdl))
618 return FALSE;
619
620 std::lock_guard<CriticalSection> lock(sdl->critical);
621 if (!freerdp_settings_get_bool(settings, FreeRDP_UseCommonStdioCallbacks))
622 sdl->connection_dialog = std::make_unique<SDLConnectionDialog>(instance->context);
623 if (sdl->connection_dialog)
624 {
625 sdl->connection_dialog->setTitle("Connecting to '%s'",
627 sdl->connection_dialog->showInfo(
628 "The connection is being established\n\nPlease wait...");
629 }
630 if (!sdl_detect_monitors(sdl, &maxWidth, &maxHeight))
631 return FALSE;
632
633 if ((maxWidth != 0) && (maxHeight != 0) &&
634 !freerdp_settings_get_bool(settings, FreeRDP_SmartSizing))
635 {
636 WLog_Print(sdl->log, WLOG_INFO, "Update size to %ux%u", maxWidth, maxHeight);
637 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, maxWidth))
638 return FALSE;
639 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, maxHeight))
640 return FALSE;
641 }
642 }
643 else
644 {
645 /* Check +auth-only has a username and password. */
646 if (!freerdp_settings_get_string(settings, FreeRDP_Password))
647 {
648 WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
649 return FALSE;
650 }
651
652 if (!freerdp_settings_set_bool(settings, FreeRDP_DeactivateClientDecoding, TRUE))
653 return FALSE;
654
655 WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect SDL.");
656 }
657
658 /* TODO: Any code your client requires */
659 return TRUE;
660}
661
662static const char* sdl_window_get_title(rdpSettings* settings)
663{
664 const char* windowTitle = nullptr;
665 UINT32 port = 0;
666 BOOL addPort = 0;
667 const char* name = nullptr;
668 const char* prefix = "FreeRDP:";
669
670 if (!settings)
671 return nullptr;
672
673 windowTitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
674 if (windowTitle)
675 return windowTitle;
676
677 name = freerdp_settings_get_server_name(settings);
678 port = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
679
680 addPort = (port != 3389);
681
682 char buffer[MAX_PATH + 64] = {};
683
684 if (!addPort)
685 (void)sprintf_s(buffer, sizeof(buffer), "%s %s", prefix, name);
686 else
687 (void)sprintf_s(buffer, sizeof(buffer), "%s %s:%" PRIu32, prefix, name, port);
688
689 if (!freerdp_settings_set_string(settings, FreeRDP_WindowTitle, buffer))
690 return nullptr;
691 return freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
692}
693
694static void sdl_term_handler([[maybe_unused]] int signum, [[maybe_unused]] const char* signame,
695 [[maybe_unused]] void* context)
696{
697 sdl_push_quit();
698}
699
700static void sdl_cleanup_sdl(SdlContext* sdl)
701{
702 if (!sdl)
703 return;
704
705 std::lock_guard<CriticalSection> lock(sdl->critical);
706 sdl->windows.clear();
707 sdl->connection_dialog.reset();
708
709 sdl_destroy_primary(sdl);
710
711 freerdp_del_signal_cleanup_handler(sdl->context(), sdl_term_handler);
712 TTF_Quit();
713 SDL_Quit();
714}
715
716static BOOL sdl_create_windows(SdlContext* sdl)
717{
718 WINPR_ASSERT(sdl);
719
720 auto settings = sdl->context()->settings;
721 auto title = sdl_window_get_title(settings);
722
723 ScopeGuard guard([&]() { sdl->windows_created.set(); });
724
725 UINT32 windowCount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
726
727 for (UINT32 x = 0; x < windowCount; x++)
728 {
729 auto id = sdl_monitor_id_for_index(sdl, x);
730 if (id < 0)
731 return FALSE;
732 auto monitor = static_cast<rdpMonitor*>(
733 freerdp_settings_get_pointer_array_writable(settings, FreeRDP_MonitorDefArray, x));
734
735 Uint32 w = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
736 Uint32 h = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
737 if (!(freerdp_settings_get_bool(settings, FreeRDP_UseMultimon) ||
738 freerdp_settings_get_bool(settings, FreeRDP_Fullscreen)))
739 {
740 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
741 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
742 }
743
744 Uint32 flags = SDL_WINDOW_SHOWN;
745 auto startupX = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
746 auto startupY = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
747
748 if (monitor->attributes.desktopScaleFactor > 100)
749 {
750#if SDL_VERSION_ATLEAST(2, 0, 1)
751 flags |= SDL_WINDOW_ALLOW_HIGHDPI;
752#endif
753 }
754
755 if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) &&
756 !freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
757 {
758 flags |= SDL_WINDOW_FULLSCREEN;
759 }
760
761 if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
762 {
763 flags |= SDL_WINDOW_BORDERLESS;
764 }
765
766 if (!freerdp_settings_get_bool(settings, FreeRDP_Decorations))
767 flags |= SDL_WINDOW_BORDERLESS;
768
769 SdlWindow window{ title,
770 static_cast<int>(startupX),
771 static_cast<int>(startupY),
772 static_cast<int>(w),
773 static_cast<int>(h),
774 flags };
775
776 if (!window.window())
777 return FALSE;
778
779 if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
780 {
781 auto r = window.rect();
782 window.setOffsetX(0 - r.x);
783 window.setOffsetY(0 - r.y);
784 }
785
786 sdl->windows.insert({ window.id(), std::move(window) });
787 }
788
789 return TRUE;
790}
791
792static BOOL sdl_wait_create_windows(SdlContext* sdl)
793{
794 std::lock_guard<CriticalSection> lock(sdl->critical);
795 sdl->windows_created.clear();
796 if (!sdl_push_user_event(SDL_USEREVENT_CREATE_WINDOWS, sdl))
797 return FALSE;
798
799 HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
800
801 const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
802 switch (rc)
803 {
804 case WAIT_OBJECT_0:
805 return TRUE;
806 default:
807 return FALSE;
808 }
809}
810
811static bool shall_abort(SdlContext* sdl)
812{
813 std::lock_guard<CriticalSection> lock(sdl->critical);
814 if (freerdp_shall_disconnect_context(sdl->context()))
815 {
816 if (sdl->rdp_thread_running)
817 return false;
818 if (!sdl->connection_dialog)
819 return true;
820 return !sdl->connection_dialog->running();
821 }
822 return false;
823}
824
825static int sdl_run(SdlContext* sdl)
826{
827 int rc = -1;
828 WINPR_ASSERT(sdl);
829
830 HANDLE handles[] = { sdl->initialize.handle(), freerdp_abort_event(sdl->context()) };
831 const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
832 switch (status)
833 {
834 case WAIT_OBJECT_0:
835 break;
836 default:
837 return 0;
838 }
839
840 SDL_Init(SDL_INIT_VIDEO);
841 TTF_Init();
842#if SDL_VERSION_ATLEAST(2, 0, 16)
843 SDL_SetHint(SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED, "0");
844#endif
845#if SDL_VERSION_ATLEAST(2, 0, 8)
846 SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0");
847#endif
848
849 freerdp_add_signal_cleanup_handler(sdl->context(), sdl_term_handler);
850
851 sdl->initialized.set();
852
853 while (!shall_abort(sdl))
854 {
855 SDL_Event windowEvent = {};
856 while (!shall_abort(sdl) && SDL_WaitEventTimeout(nullptr, 1000))
857 {
858 /* Only poll standard SDL events and SDL_USEREVENTS meant to create dialogs.
859 * do not process the dialog return value events here.
860 */
861 const int prc = SDL_PeepEvents(&windowEvent, 1, SDL_GETEVENT, SDL_FIRSTEVENT,
862 SDL_USEREVENT_RETRY_DIALOG);
863 if (prc < 0)
864 {
865 if (sdl_log_error(prc, sdl->log, "SDL_PeepEvents"))
866 continue;
867 }
868
869#if defined(WITH_DEBUG_SDL_EVENTS)
870 SDL_Log("got event %s [0x%08" PRIx32 "]", sdl_event_type_str(windowEvent.type),
871 windowEvent.type);
872#endif
873 std::lock_guard<CriticalSection> lock(sdl->critical);
874 /* The session might have been disconnected while we were waiting for a new SDL event.
875 * In that case ignore the SDL event and terminate. */
876 if (freerdp_shall_disconnect_context(sdl->context()))
877 continue;
878
879 if (sdl->connection_dialog)
880 {
881 if (sdl->connection_dialog->handle(windowEvent))
882 {
883 continue;
884 }
885 }
886
887 switch (windowEvent.type)
888 {
889 case SDL_QUIT:
890 freerdp_abort_connect_context(sdl->context());
891 break;
892 case SDL_KEYDOWN:
893 case SDL_KEYUP:
894 {
895 const SDL_KeyboardEvent* ev = &windowEvent.key;
896 sdl->input.keyboard_handle_event(ev);
897 }
898 break;
899 case SDL_KEYMAPCHANGED:
900 {
901 }
902 break; // TODO: Switch keyboard layout
903 case SDL_MOUSEMOTION:
904 {
905 const SDL_MouseMotionEvent* ev = &windowEvent.motion;
906 sdl_handle_mouse_motion(sdl, ev);
907 }
908 break;
909 case SDL_MOUSEBUTTONDOWN:
910 case SDL_MOUSEBUTTONUP:
911 {
912 const SDL_MouseButtonEvent* ev = &windowEvent.button;
913 sdl_handle_mouse_button(sdl, ev);
914 }
915 break;
916 case SDL_MOUSEWHEEL:
917 {
918 const SDL_MouseWheelEvent* ev = &windowEvent.wheel;
919 sdl_handle_mouse_wheel(sdl, ev);
920 }
921 break;
922 case SDL_FINGERDOWN:
923 {
924 const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
925 sdl_handle_touch_down(sdl, ev);
926 }
927 break;
928 case SDL_FINGERUP:
929 {
930 const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
931 sdl_handle_touch_up(sdl, ev);
932 }
933 break;
934 case SDL_FINGERMOTION:
935 {
936 const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
937 sdl_handle_touch_motion(sdl, ev);
938 }
939 break;
940#if SDL_VERSION_ATLEAST(2, 0, 10)
941 case SDL_DISPLAYEVENT:
942 {
943 const SDL_DisplayEvent* ev = &windowEvent.display;
944 sdl->disp.handle_display_event(ev);
945 }
946 break;
947#endif
948 case SDL_WINDOWEVENT:
949 {
950 const SDL_WindowEvent* ev = &windowEvent.window;
951 auto window = sdl->windows.find(ev->windowID);
952 if (window != sdl->windows.end())
953 sdl->disp.handle_window_event(ev);
954 switch (ev->event)
955 {
956 case SDL_WINDOWEVENT_RESIZED:
957 case SDL_WINDOWEVENT_SIZE_CHANGED:
958 {
959 if (window != sdl->windows.end())
960 {
961 window->second.fill();
962 window->second.updateSurface();
963 }
964 }
965 break;
966 case SDL_WINDOWEVENT_MOVED:
967 {
968 if (window != sdl->windows.end())
969 {
970 auto r = window->second.rect();
971 auto id = window->second.id();
972 WLog_DBG(SDL_TAG, "%lu: %dx%d-%dx%d", id, r.x, r.y, r.w, r.h);
973 }
974 }
975 break;
976 default:
977 break;
978 }
979 }
980 break;
981
982 case SDL_RENDER_TARGETS_RESET:
983 sdl_redraw(sdl);
984 break;
985 case SDL_RENDER_DEVICE_RESET:
986 sdl_redraw(sdl);
987 break;
988 case SDL_APP_WILLENTERFOREGROUND:
989 sdl_redraw(sdl);
990 break;
991 case SDL_USEREVENT_CERT_DIALOG:
992 {
993 auto title = static_cast<const char*>(windowEvent.user.data1);
994 auto msg = static_cast<const char*>(windowEvent.user.data2);
995 sdl_cert_dialog_show(title, msg);
996 }
997 break;
998 case SDL_USEREVENT_SHOW_DIALOG:
999 {
1000 auto title = static_cast<const char*>(windowEvent.user.data1);
1001 auto msg = static_cast<const char*>(windowEvent.user.data2);
1002 sdl_message_dialog_show(title, msg, windowEvent.user.code);
1003 }
1004 break;
1005 case SDL_USEREVENT_SCARD_DIALOG:
1006 {
1007 auto title = static_cast<const char*>(windowEvent.user.data1);
1008 auto msg = static_cast<const char**>(windowEvent.user.data2);
1009 sdl_scard_dialog_show(title, windowEvent.user.code, msg);
1010 }
1011 break;
1012 case SDL_USEREVENT_AUTH_DIALOG:
1013 sdl_auth_dialog_show(
1014 reinterpret_cast<const SDL_UserAuthArg*>(windowEvent.padding));
1015 break;
1016 case SDL_USEREVENT_UPDATE:
1017 {
1018 auto context = static_cast<rdpContext*>(windowEvent.user.data1);
1019 sdl_end_paint_process(context);
1020 }
1021 break;
1022 case SDL_USEREVENT_CREATE_WINDOWS:
1023 {
1024 auto ctx = static_cast<SdlContext*>(windowEvent.user.data1);
1025 sdl_create_windows(ctx);
1026 }
1027 break;
1028 case SDL_USEREVENT_WINDOW_RESIZEABLE:
1029 {
1030 auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
1031 const SDL_bool use = windowEvent.user.code != 0 ? SDL_TRUE : SDL_FALSE;
1032 if (window)
1033 window->resizeable(use);
1034 }
1035 break;
1036 case SDL_USEREVENT_WINDOW_FULLSCREEN:
1037 {
1038 auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
1039 const SDL_bool enter = windowEvent.user.code != 0 ? SDL_TRUE : SDL_FALSE;
1040 if (window)
1041 window->fullscreen(enter);
1042 }
1043 break;
1044 case SDL_USEREVENT_WINDOW_MINIMIZE:
1045 {
1046 for (auto& window : sdl->windows)
1047 {
1048 window.second.minimize();
1049 }
1050 }
1051 break;
1052 case SDL_USEREVENT_POINTER_NULL:
1053 SDL_ShowCursor(SDL_DISABLE);
1054 break;
1055 case SDL_USEREVENT_POINTER_DEFAULT:
1056 {
1057 SDL_Cursor* def = SDL_GetDefaultCursor();
1058 SDL_SetCursor(def);
1059 SDL_ShowCursor(SDL_ENABLE);
1060 }
1061 break;
1062 case SDL_USEREVENT_POINTER_POSITION:
1063 {
1064 const auto x =
1065 static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data1));
1066 const auto y =
1067 static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data2));
1068
1069 SDL_Window* window = SDL_GetMouseFocus();
1070 if (window)
1071 {
1072 const Uint32 id = SDL_GetWindowID(window);
1073
1074 INT32 sx = x;
1075 INT32 sy = y;
1076 if (sdl_scale_coordinates(sdl, id, &sx, &sy, FALSE, FALSE))
1077 SDL_WarpMouseInWindow(window, sx, sy);
1078 }
1079 }
1080 break;
1081 case SDL_USEREVENT_POINTER_SET:
1082 sdl_Pointer_Set_Process(&windowEvent.user);
1083 break;
1084 case SDL_USEREVENT_QUIT:
1085 default:
1086 break;
1087 }
1088 }
1089 }
1090
1091 rc = 1;
1092
1093 sdl_cleanup_sdl(sdl);
1094 return rc;
1095}
1096
1097/* Called after a RDP connection was successfully established.
1098 * Settings might have changed during negotiation of client / server feature
1099 * support.
1100 *
1101 * Set up local framebuffers and paing callbacks.
1102 * If required, register pointer callbacks to change the local mouse cursor
1103 * when hovering over the RDP window
1104 */
1105static BOOL sdl_post_connect(freerdp* instance)
1106{
1107 WINPR_ASSERT(instance);
1108
1109 auto context = instance->context;
1110 WINPR_ASSERT(context);
1111
1112 auto sdl = get_context(context);
1113
1114 // Retry was successful, discard dialog
1115 sdl_hide_connection_dialog(sdl);
1116
1117 if (freerdp_settings_get_bool(context->settings, FreeRDP_AuthenticationOnly))
1118 {
1119 /* Check +auth-only has a username and password. */
1120 if (!freerdp_settings_get_string(context->settings, FreeRDP_Password))
1121 {
1122 WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
1123 return FALSE;
1124 }
1125
1126 WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect to X.");
1127 return TRUE;
1128 }
1129
1130 if (!sdl_wait_create_windows(sdl))
1131 return FALSE;
1132
1133 sdl->sdl_pixel_format = SDL_PIXELFORMAT_BGRA32;
1134 if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
1135 return FALSE;
1136
1137 if (!sdl_create_primary(sdl))
1138 return FALSE;
1139
1140 if (!sdl_register_pointer(instance->context->graphics))
1141 return FALSE;
1142
1143 WINPR_ASSERT(context->update);
1144
1145 context->update->BeginPaint = sdl_begin_paint;
1146 context->update->EndPaint = sdl_end_paint;
1147 context->update->PlaySound = sdl_play_sound;
1148 context->update->DesktopResize = sdl_desktop_resize;
1149 context->update->SetKeyboardIndicators = sdlInput::keyboard_set_indicators;
1150 context->update->SetKeyboardImeStatus = sdlInput::keyboard_set_ime_status;
1151
1152 sdl->update_resizeable(FALSE);
1153 sdl->update_fullscreen(freerdp_settings_get_bool(context->settings, FreeRDP_Fullscreen) ||
1154 freerdp_settings_get_bool(context->settings, FreeRDP_UseMultimon));
1155 return TRUE;
1156}
1157
1158/* This function is called whether a session ends by failure or success.
1159 * Clean up everything allocated by pre_connect and post_connect.
1160 */
1161static void sdl_post_disconnect(freerdp* instance)
1162{
1163 if (!instance)
1164 return;
1165
1166 if (!instance->context)
1167 return;
1168
1169 PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
1170 sdl_OnChannelConnectedEventHandler);
1171 PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
1172 sdl_OnChannelDisconnectedEventHandler);
1173 gdi_free(instance);
1174}
1175
1176static void sdl_post_final_disconnect(freerdp* instance)
1177{
1178 if (!instance)
1179 return;
1180
1181 if (!instance->context)
1182 return;
1183}
1184
1185static void sdl_client_cleanup(SdlContext* sdl, int exit_code, const std::string& error_msg)
1186{
1187 WINPR_ASSERT(sdl);
1188
1189 rdpContext* context = sdl->context();
1190 WINPR_ASSERT(context);
1191
1192 rdpSettings* settings = context->settings;
1193 WINPR_ASSERT(settings);
1194
1195 sdl->rdp_thread_running = false;
1196 bool showError = false;
1197 if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
1198 WLog_Print(sdl->log, WLOG_INFO, "Authentication only, exit status %s [%" PRId32 "]",
1199 sdl_map_to_code_tag(exit_code), exit_code);
1200 else
1201 {
1202 switch (exit_code)
1203 {
1204 case SDL_EXIT_SUCCESS:
1205 case SDL_EXIT_DISCONNECT:
1206 case SDL_EXIT_LOGOFF:
1207 case SDL_EXIT_DISCONNECT_BY_USER:
1208 case SDL_EXIT_CONNECT_CANCELLED:
1209 break;
1210 default:
1211 {
1212 std::lock_guard<CriticalSection> lock(sdl->critical);
1213 if (sdl->connection_dialog && !error_msg.empty())
1214 {
1215 sdl->connection_dialog->showError(error_msg.c_str());
1216 showError = true;
1217 }
1218 }
1219 break;
1220 }
1221 }
1222
1223 if (!showError)
1224 sdl_hide_connection_dialog(sdl);
1225
1226 sdl->exit_code = exit_code;
1227 sdl_push_user_event(SDL_USEREVENT_QUIT);
1228#if SDL_VERSION_ATLEAST(2, 0, 16)
1229 SDL_TLSCleanup();
1230#endif
1231}
1232
1233static int sdl_client_thread_connect(SdlContext* sdl, std::string& error_msg)
1234{
1235 WINPR_ASSERT(sdl);
1236
1237 auto instance = sdl->context()->instance;
1238 WINPR_ASSERT(instance);
1239
1240 sdl->rdp_thread_running = true;
1241 BOOL rc = freerdp_connect(instance);
1242
1243 rdpContext* context = sdl->context();
1244 WINPR_ASSERT(context);
1245
1246 rdpSettings* settings = context->settings;
1247 WINPR_ASSERT(settings);
1248
1249 int exit_code = SDL_EXIT_SUCCESS;
1250 if (!rc)
1251 {
1252 UINT32 error = freerdp_get_last_error(context);
1253 exit_code = sdl_map_error_to_exit_code(error);
1254 }
1255
1256 if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
1257 {
1258 DWORD code = freerdp_get_last_error(context);
1259 freerdp_abort_connect_context(context);
1260 WLog_Print(sdl->log, WLOG_ERROR, "Authentication only, %s [0x%08" PRIx32 "] %s",
1261 freerdp_get_last_error_name(code), code, freerdp_get_last_error_string(code));
1262 return exit_code;
1263 }
1264
1265 if (!rc)
1266 {
1267 DWORD code = freerdp_error_info(instance);
1268 if (exit_code == SDL_EXIT_SUCCESS)
1269 {
1270 char* msg = nullptr;
1271 size_t len = 0;
1272 exit_code = error_info_to_error(instance, &code, &msg, &len);
1273 if (msg)
1274 error_msg = msg;
1275 free(msg);
1276 }
1277
1278 auto last = freerdp_get_last_error(context);
1279 if (error_msg.empty())
1280 {
1281 char* msg = nullptr;
1282 size_t len = 0;
1283 winpr_asprintf(&msg, &len, "%s [0x%08" PRIx32 "]\n%s",
1284 freerdp_get_last_error_name(last), last,
1285 freerdp_get_last_error_string(last));
1286 if (msg)
1287 error_msg = msg;
1288 free(msg);
1289 }
1290
1291 if (exit_code == SDL_EXIT_SUCCESS)
1292 {
1293 if (last == FREERDP_ERROR_AUTHENTICATION_FAILED)
1294 exit_code = SDL_EXIT_AUTH_FAILURE;
1295 else if (code == ERRINFO_SUCCESS)
1296 exit_code = SDL_EXIT_CONN_FAILED;
1297 }
1298
1299 sdl_hide_connection_dialog(sdl);
1300 }
1301 return exit_code;
1302}
1303
1304static int sdl_client_thread_run(SdlContext* sdl, std::string& error_msg)
1305{
1306 WINPR_ASSERT(sdl);
1307
1308 auto context = sdl->context();
1309 WINPR_ASSERT(context);
1310
1311 auto instance = context->instance;
1312 WINPR_ASSERT(instance);
1313
1314 int exit_code = SDL_EXIT_SUCCESS;
1315 while (!freerdp_shall_disconnect_context(context))
1316 {
1317 HANDLE handles[MAXIMUM_WAIT_OBJECTS] = {};
1318 /*
1319 * win8 and server 2k12 seem to have some timing issue/race condition
1320 * when a initial sync request is send to sync the keyboard indicators
1321 * sending the sync event twice fixed this problem
1322 */
1323 if (freerdp_focus_required(instance))
1324 {
1325 auto ctx = get_context(context);
1326 WINPR_ASSERT(ctx);
1327 if (!ctx->input.keyboard_focus_in())
1328 break;
1329 if (!ctx->input.keyboard_focus_in())
1330 break;
1331 }
1332
1333 const DWORD nCount = freerdp_get_event_handles(context, handles, ARRAYSIZE(handles));
1334
1335 if (nCount == 0)
1336 {
1337 WLog_Print(sdl->log, WLOG_ERROR, "freerdp_get_event_handles failed");
1338 break;
1339 }
1340
1341 const DWORD status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
1342
1343 if (status == WAIT_FAILED)
1344 break;
1345
1346 if (!freerdp_check_event_handles(context))
1347 {
1348 if (client_auto_reconnect(instance))
1349 {
1350 // Retry was successful, discard dialog
1351 sdl_hide_connection_dialog(sdl);
1352 continue;
1353 }
1354 else
1355 {
1356 /*
1357 * Indicate an unsuccessful connection attempt if reconnect
1358 * did not succeed and no other error was specified.
1359 */
1360 if (freerdp_error_info(instance) == 0)
1361 exit_code = SDL_EXIT_CONN_FAILED;
1362 }
1363
1364 if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
1365 WLog_Print(sdl->log, WLOG_ERROR, "WaitForMultipleObjects failed with %" PRIu32 "",
1366 status);
1367 if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
1368 WLog_Print(sdl->log, WLOG_ERROR, "Failed to check FreeRDP event handles");
1369 break;
1370 }
1371 }
1372
1373 if (exit_code == SDL_EXIT_SUCCESS)
1374 {
1375 DWORD code = 0;
1376 {
1377 char* msg = nullptr;
1378 size_t len = 0;
1379 exit_code = error_info_to_error(instance, &code, &msg, &len);
1380 if (msg)
1381 error_msg = msg;
1382 free(msg);
1383 }
1384
1385 if ((code == ERRINFO_LOGOFF_BY_USER) &&
1386 (freerdp_get_disconnect_ultimatum(context) == Disconnect_Ultimatum_user_requested))
1387 {
1388 const char* msg = "Error info says user did not initiate but disconnect ultimatum says "
1389 "they did; treat this as a user logoff";
1390 char* emsg = nullptr;
1391 size_t len = 0;
1392 winpr_asprintf(&emsg, &len, "%s", msg);
1393 if (emsg)
1394 error_msg = emsg;
1395 free(emsg);
1396 /* This situation might be limited to Windows XP. */
1397 WLog_Print(sdl->log, WLOG_INFO, "%s", msg);
1398 exit_code = SDL_EXIT_LOGOFF;
1399 }
1400 }
1401
1402 freerdp_disconnect(instance);
1403 return exit_code;
1404}
1405
1406/* RDP main loop.
1407 * Connects RDP, loops while running and handles event and dispatch, cleans up
1408 * after the connection ends. */
1409static DWORD WINAPI sdl_client_thread_proc(SdlContext* sdl)
1410{
1411 WINPR_ASSERT(sdl);
1412
1413 std::string error_msg;
1414 int exit_code = sdl_client_thread_connect(sdl, error_msg);
1415 if (exit_code == SDL_EXIT_SUCCESS)
1416 exit_code = sdl_client_thread_run(sdl, error_msg);
1417 sdl_client_cleanup(sdl, exit_code, error_msg);
1418
1419 return static_cast<DWORD>(exit_code);
1420}
1421
1422/* Optional global initializer.
1423 * Here we just register a signal handler to print out stack traces
1424 * if available. */
1425static BOOL sdl_client_global_init()
1426{
1427#if defined(_WIN32)
1428 WSADATA wsaData = {};
1429 const DWORD wVersionRequested = MAKEWORD(1, 1);
1430 const int rc = WSAStartup(wVersionRequested, &wsaData);
1431 if (rc != 0)
1432 {
1433 WLog_ERR(SDL_TAG, "WSAStartup failed with %s [%d]", gai_strerrorA(rc), rc);
1434 return FALSE;
1435 }
1436#endif
1437
1438 return freerdp_handle_signals() != 0;
1439}
1440
1441/* Optional global tear down */
1442static void sdl_client_global_uninit()
1443{
1444#if defined(_WIN32)
1445 WSACleanup();
1446#endif
1447}
1448
1449static BOOL sdl_client_new(freerdp* instance, rdpContext* context)
1450{
1451 auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
1452
1453 if (!instance || !context)
1454 return FALSE;
1455
1456 sdl->sdl = new SdlContext(context);
1457 if (!sdl->sdl)
1458 return FALSE;
1459
1460 instance->PreConnect = sdl_pre_connect;
1461 instance->PostConnect = sdl_post_connect;
1462 instance->PostDisconnect = sdl_post_disconnect;
1463 instance->PostFinalDisconnect = sdl_post_final_disconnect;
1464 instance->AuthenticateEx = sdl_authenticate_ex;
1465 instance->VerifyCertificateEx = sdl_verify_certificate_ex;
1466 instance->VerifyChangedCertificateEx = sdl_verify_changed_certificate_ex;
1467 instance->LogonErrorInfo = sdl_logon_error_info;
1468 instance->PresentGatewayMessage = sdl_present_gateway_message;
1469 instance->ChooseSmartcard = sdl_choose_smartcard;
1470 instance->RetryDialog = sdl_retry_dialog;
1471
1472#if defined(WITH_WEBVIEW)
1473 instance->GetAccessToken = sdl_webview_get_access_token;
1474#else
1475 instance->GetAccessToken = client_cli_get_access_token;
1476#endif
1477 /* TODO: Client display set up */
1478
1479 return TRUE;
1480}
1481
1482static void sdl_client_free([[maybe_unused]] freerdp* instance, rdpContext* context)
1483{
1484 auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
1485
1486 if (!context)
1487 return;
1488
1489 delete sdl->sdl;
1490}
1491
1492static int sdl_client_start(rdpContext* context)
1493{
1494 auto sdl = get_context(context);
1495 WINPR_ASSERT(sdl);
1496
1497 sdl->thread = std::thread(sdl_client_thread_proc, sdl);
1498 return 0;
1499}
1500
1501static int sdl_client_stop(rdpContext* context)
1502{
1503 auto sdl = get_context(context);
1504 WINPR_ASSERT(sdl);
1505
1506 /* We do not want to use freerdp_abort_connect_context here.
1507 * It would change the exit code and we do not want that. */
1508 HANDLE event = freerdp_abort_event(context);
1509 if (!SetEvent(event))
1510 return -1;
1511
1512 sdl->thread.join();
1513 return 0;
1514}
1515
1516static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
1517{
1518 WINPR_ASSERT(pEntryPoints);
1519
1520 ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
1521 pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
1522 pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
1523 pEntryPoints->GlobalInit = sdl_client_global_init;
1524 pEntryPoints->GlobalUninit = sdl_client_global_uninit;
1525 pEntryPoints->ContextSize = sizeof(sdl_rdp_context);
1526 pEntryPoints->ClientNew = sdl_client_new;
1527 pEntryPoints->ClientFree = sdl_client_free;
1528 pEntryPoints->ClientStart = sdl_client_start;
1529 pEntryPoints->ClientStop = sdl_client_stop;
1530 return 0;
1531}
1532
1533static void context_free(sdl_rdp_context* sdl)
1534{
1535 if (sdl)
1536 freerdp_client_context_free(&sdl->common.context);
1537}
1538
1539static const char* category2str(int category)
1540{
1541 switch (category)
1542 {
1543 case SDL_LOG_CATEGORY_APPLICATION:
1544 return "SDL_LOG_CATEGORY_APPLICATION";
1545 case SDL_LOG_CATEGORY_ERROR:
1546 return "SDL_LOG_CATEGORY_ERROR";
1547 case SDL_LOG_CATEGORY_ASSERT:
1548 return "SDL_LOG_CATEGORY_ASSERT";
1549 case SDL_LOG_CATEGORY_SYSTEM:
1550 return "SDL_LOG_CATEGORY_SYSTEM";
1551 case SDL_LOG_CATEGORY_AUDIO:
1552 return "SDL_LOG_CATEGORY_AUDIO";
1553 case SDL_LOG_CATEGORY_VIDEO:
1554 return "SDL_LOG_CATEGORY_VIDEO";
1555 case SDL_LOG_CATEGORY_RENDER:
1556 return "SDL_LOG_CATEGORY_RENDER";
1557 case SDL_LOG_CATEGORY_INPUT:
1558 return "SDL_LOG_CATEGORY_INPUT";
1559 case SDL_LOG_CATEGORY_TEST:
1560 return "SDL_LOG_CATEGORY_TEST";
1561 case SDL_LOG_CATEGORY_RESERVED1:
1562 return "SDL_LOG_CATEGORY_RESERVED1";
1563 case SDL_LOG_CATEGORY_RESERVED2:
1564 return "SDL_LOG_CATEGORY_RESERVED2";
1565 case SDL_LOG_CATEGORY_RESERVED3:
1566 return "SDL_LOG_CATEGORY_RESERVED3";
1567 case SDL_LOG_CATEGORY_RESERVED4:
1568 return "SDL_LOG_CATEGORY_RESERVED4";
1569 case SDL_LOG_CATEGORY_RESERVED5:
1570 return "SDL_LOG_CATEGORY_RESERVED5";
1571 case SDL_LOG_CATEGORY_RESERVED6:
1572 return "SDL_LOG_CATEGORY_RESERVED6";
1573 case SDL_LOG_CATEGORY_RESERVED7:
1574 return "SDL_LOG_CATEGORY_RESERVED7";
1575 case SDL_LOG_CATEGORY_RESERVED8:
1576 return "SDL_LOG_CATEGORY_RESERVED8";
1577 case SDL_LOG_CATEGORY_RESERVED9:
1578 return "SDL_LOG_CATEGORY_RESERVED9";
1579 case SDL_LOG_CATEGORY_RESERVED10:
1580 return "SDL_LOG_CATEGORY_RESERVED10";
1581 case SDL_LOG_CATEGORY_CUSTOM:
1582 default:
1583 return "SDL_LOG_CATEGORY_CUSTOM";
1584 }
1585}
1586
1587static SDL_LogPriority wloglevel2dl(DWORD level)
1588{
1589 switch (level)
1590 {
1591 case WLOG_TRACE:
1592 return SDL_LOG_PRIORITY_VERBOSE;
1593 case WLOG_DEBUG:
1594 return SDL_LOG_PRIORITY_DEBUG;
1595 case WLOG_INFO:
1596 return SDL_LOG_PRIORITY_INFO;
1597 case WLOG_WARN:
1598 return SDL_LOG_PRIORITY_WARN;
1599 case WLOG_ERROR:
1600 return SDL_LOG_PRIORITY_ERROR;
1601 case WLOG_FATAL:
1602 return SDL_LOG_PRIORITY_CRITICAL;
1603 case WLOG_OFF:
1604 default:
1605 return SDL_LOG_PRIORITY_VERBOSE;
1606 }
1607}
1608
1609static DWORD sdlpriority2wlog(SDL_LogPriority priority)
1610{
1611 DWORD level = WLOG_OFF;
1612 switch (priority)
1613 {
1614 case SDL_LOG_PRIORITY_VERBOSE:
1615 level = WLOG_TRACE;
1616 break;
1617 case SDL_LOG_PRIORITY_DEBUG:
1618 level = WLOG_DEBUG;
1619 break;
1620 case SDL_LOG_PRIORITY_INFO:
1621 level = WLOG_INFO;
1622 break;
1623 case SDL_LOG_PRIORITY_WARN:
1624 level = WLOG_WARN;
1625 break;
1626 case SDL_LOG_PRIORITY_ERROR:
1627 level = WLOG_ERROR;
1628 break;
1629 case SDL_LOG_PRIORITY_CRITICAL:
1630 level = WLOG_FATAL;
1631 break;
1632 default:
1633 break;
1634 }
1635
1636 return level;
1637}
1638
1639static void SDLCALL winpr_LogOutputFunction(void* userdata, int category, SDL_LogPriority priority,
1640 const char* message)
1641{
1642 auto sdl = static_cast<SdlContext*>(userdata);
1643 WINPR_ASSERT(sdl);
1644
1645 const DWORD level = sdlpriority2wlog(priority);
1646 auto log = sdl->log;
1647 if (!WLog_IsLevelActive(log, level))
1648 return;
1649
1650 WLog_PrintTextMessage(log, level, __LINE__, __FILE__, __func__, "[%s] %s",
1651 category2str(category), message);
1652}
1653
1654int main(int argc, char* argv[])
1655{
1656 int rc = -1;
1657 int status = 0;
1658 RDP_CLIENT_ENTRY_POINTS clientEntryPoints = {};
1659
1660 freerdp_client_warn_experimental(argc, argv);
1661 freerdp_client_warn_deprecated(argc, argv);
1662 WLog_WARN(SDL_TAG,
1663 "SDL2 client does not support clipboard! Only SDL3 client has (partial) support");
1664
1665 RdpClientEntry(&clientEntryPoints);
1666 std::unique_ptr<sdl_rdp_context, void (*)(sdl_rdp_context*)> sdl_rdp(
1667 reinterpret_cast<sdl_rdp_context*>(freerdp_client_context_new(&clientEntryPoints)),
1668 context_free);
1669
1670 if (!sdl_rdp)
1671 return -1;
1672 auto sdl = sdl_rdp->sdl;
1673
1674 auto settings = sdl->context()->settings;
1675 WINPR_ASSERT(settings);
1676
1677 status = freerdp_client_settings_parse_command_line(settings, argc, argv, FALSE);
1678 if (status)
1679 {
1680 rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
1681 if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
1682 sdl_list_monitors(sdl);
1683 else
1684 {
1685 switch (status)
1686 {
1687 case COMMAND_LINE_STATUS_PRINT:
1688 case COMMAND_LINE_STATUS_PRINT_VERSION:
1689 case COMMAND_LINE_STATUS_PRINT_BUILDCONFIG:
1690 break;
1691 case COMMAND_LINE_STATUS_PRINT_HELP:
1692 default:
1693 SdlPref::print_config_file_help(2);
1694 break;
1695 }
1696 }
1697 return rc;
1698 }
1699
1700 SDL_LogSetOutputFunction(winpr_LogOutputFunction, sdl);
1701 auto level = WLog_GetLogLevel(sdl->log);
1702 SDL_LogSetAllPriority(wloglevel2dl(level));
1703
1704 auto context = sdl->context();
1705 WINPR_ASSERT(context);
1706
1707 if (!stream_dump_register_handlers(context, CONNECTION_STATE_MCS_CREATE_REQUEST, FALSE))
1708 return -1;
1709
1710 if (freerdp_client_start(context) != 0)
1711 return -1;
1712
1713 rc = sdl_run(sdl);
1714
1715 if (freerdp_client_stop(context) != 0)
1716 return -1;
1717
1718 if (sdl->exit_code != 0)
1719 rc = sdl->exit_code;
1720
1721 return rc;
1722}
1723
1724BOOL SdlContext::update_fullscreen(BOOL enter)
1725{
1726 std::lock_guard<CriticalSection> lock(critical);
1727 for (const auto& window : windows)
1728 {
1729 if (!sdl_push_user_event(SDL_USEREVENT_WINDOW_FULLSCREEN, &window.second, enter))
1730 return FALSE;
1731 }
1732 fullscreen = enter;
1733 return TRUE;
1734}
1735
1736BOOL SdlContext::update_minimize()
1737{
1738 std::lock_guard<CriticalSection> lock(critical);
1739 return sdl_push_user_event(SDL_USEREVENT_WINDOW_MINIMIZE);
1740}
1741
1742BOOL SdlContext::update_resizeable(BOOL enable)
1743{
1744 std::lock_guard<CriticalSection> lock(critical);
1745
1746 const auto settings = context()->settings;
1747 const BOOL dyn = freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate);
1748 const BOOL smart = freerdp_settings_get_bool(settings, FreeRDP_SmartSizing);
1749 BOOL use = (dyn && enable) || smart;
1750
1751 for (const auto& window : windows)
1752 {
1753 if (!sdl_push_user_event(SDL_USEREVENT_WINDOW_RESIZEABLE, &window.second, use))
1754 return FALSE;
1755 }
1756 resizeable = use;
1757
1758 return TRUE;
1759}
1760
1761SdlContext::SdlContext(rdpContext* context)
1762 : _context(context), log(WLog_Get(SDL_TAG)), update_complete(true), disp(this), input(this),
1763 primary(nullptr, SDL_FreeSurface), primary_format(nullptr, SDL_FreeFormat),
1764 rdp_thread_running(false)
1765{
1766 WINPR_ASSERT(context);
1767 grab_kbd_enabled = freerdp_settings_get_bool(context->settings, FreeRDP_GrabKeyboard);
1768}
1769
1770rdpContext* SdlContext::context() const
1771{
1772 return _context;
1773}
1774
1775rdpClientContext* SdlContext::common() const
1776{
1777 return reinterpret_cast<rdpClientContext*>(_context);
1778}
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *param)
Sets a string settings value. The param is copied.
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
FREERDP_API const char * freerdp_settings_get_server_name(const rdpSettings *settings)
A helper function to return the correct server name.
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.