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