FreeRDP
Loading...
Searching...
No Matches
SDL3/sdl_utils.cpp
1
19
20#include <cassert>
21#include <sstream>
22#include <iomanip>
23#include <random>
24
25#include "sdl_utils.hpp"
26
27#include "sdl_freerdp.hpp"
28
29#include <SDL3/SDL.h>
30
31#include <freerdp/version.h>
32#include <freerdp/utils/string.h>
33
34#define STR(x) #x
35#define EV_CASE_STR(x) \
36 case x: \
37 return STR(x)
38
39const char* sdl_error_string(Sint32 res)
40{
41 if (res == 0)
42 return nullptr;
43
44 return SDL_GetError();
45}
46
47BOOL sdl_log_error_ex(Sint32 res, wLog* log, const char* what, const char* file, size_t line,
48 const char* fkt)
49{
50 const char* msg = sdl_error_string(res);
51
52 WINPR_UNUSED(file);
53
54 if (!msg)
55 return FALSE;
56
57 WLog_Print(log, WLOG_ERROR, "[%s:%" PRIuz "][%s]: %s", fkt, line, what, msg);
58 return TRUE;
59}
60
61[[nodiscard]] static Uint32 SDLCALL sdl_push_update_cb(WINPR_ATTR_UNUSED void* userdata,
62 WINPR_ATTR_UNUSED SDL_TimerID timerID,
63 WINPR_ATTR_UNUSED Uint32 interval)
64{
65 if (!sdl_push_user_event(SDL_EVENT_USER_UPDATE))
66 WLog_WARN(CLIENT_TAG("sdl.utils"), "sdl_push_user_event failed");
67 return 0;
68}
69
70bool sdl_push_update_after(Uint32 ms)
71{
72 return SDL_AddTimer(ms, sdl_push_update_cb, nullptr) != 0;
73}
74
75bool sdl_push_user_event(Uint32 type, ...)
76{
77 SDL_Event ev = {};
78 SDL_UserEvent* event = &ev.user;
79
80 va_list ap = {};
81 va_start(ap, type);
82 event->type = type;
83 switch (type)
84 {
85 case SDL_EVENT_USER_AUTH_RESULT:
86 {
87 auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
88 arg->user = va_arg(ap, char*);
89 arg->domain = va_arg(ap, char*);
90 arg->password = va_arg(ap, char*);
91 arg->result = va_arg(ap, Sint32);
92 }
93 break;
94 case SDL_EVENT_USER_AUTH_DIALOG:
95 {
96 auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
97
98 arg->title = va_arg(ap, char*);
99 arg->user = va_arg(ap, char*);
100 arg->domain = va_arg(ap, char*);
101 arg->password = va_arg(ap, char*);
102 arg->result = va_arg(ap, Sint32);
103 }
104 break;
105 case SDL_EVENT_USER_SCARD_DIALOG:
106 {
107 event->data1 = va_arg(ap, char*);
108 event->data2 = va_arg(ap, char**);
109 event->code = va_arg(ap, Sint32);
110 }
111 break;
112 case SDL_EVENT_USER_RETRY_DIALOG:
113 event->code = va_arg(ap, Sint32);
114 break;
115 case SDL_EVENT_USER_SCARD_RESULT:
116 case SDL_EVENT_USER_SHOW_RESULT:
117 case SDL_EVENT_USER_CERT_RESULT:
118 event->code = va_arg(ap, Sint32);
119 break;
120
121 case SDL_EVENT_USER_SHOW_DIALOG:
122 event->data1 = va_arg(ap, char*);
123 event->data2 = va_arg(ap, char*);
124 event->code = va_arg(ap, Sint32);
125 break;
126 case SDL_EVENT_USER_CERT_DIALOG:
127 event->data1 = va_arg(ap, char*);
128 event->data2 = va_arg(ap, char*);
129 break;
130 case SDL_EVENT_USER_UPDATE:
131 event->data1 = va_arg(ap, void*);
132 break;
133 case SDL_EVENT_USER_POINTER_POSITION:
134 event->data1 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
135 event->data2 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
136 break;
137 case SDL_EVENT_USER_POINTER_SET:
138 event->data1 = va_arg(ap, void*);
139 event->data2 = va_arg(ap, void*);
140 break;
141 case SDL_EVENT_USER_CREATE_WINDOWS:
142 event->data1 = va_arg(ap, void*);
143 break;
144 case SDL_EVENT_USER_WINDOW_FULLSCREEN:
145 event->data1 = va_arg(ap, void*);
146 event->code = va_arg(ap, int);
147 event->data2 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, int)));
148 break;
149 case SDL_EVENT_USER_WINDOW_RESIZEABLE:
150 event->data1 = va_arg(ap, void*);
151 event->code = va_arg(ap, int);
152 break;
153 case SDL_EVENT_USER_RAIL_MOVE:
154 event->data1 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
155 event->code = va_arg(ap, int); /* RAIL_WMSZ_* move/resize type */
156 break;
157 case SDL_EVENT_USER_WINDOW_MINIMIZE:
158 case SDL_EVENT_USER_OVERLAY:
159 case SDL_EVENT_USER_QUIT:
160 case SDL_EVENT_USER_POINTER_NULL:
161 case SDL_EVENT_USER_POINTER_DEFAULT:
162 case SDL_EVENT_CLIPBOARD_UPDATE:
163 case SDL_EVENT_USER_RENDERER:
164 case SDL_EVENT_USER_WINDOW_INFO:
165 break;
166 default:
167 va_end(ap);
168 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "[%s] unsupported type %u", __func__, type);
169 return false;
170 }
171 va_end(ap);
172 const auto rc = SDL_PushEvent(&ev);
173 if (rc != 1)
174 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "[%s] SDL_PushEvent returned %d", __func__, rc);
175 return rc == 1;
176}
177
178bool sdl_push_quit()
179{
180 SDL_Event ev = {};
181 ev.type = SDL_EVENT_QUIT;
182 SDL_PushEvent(&ev);
183 return true;
184}
185
186namespace sdl::utils
187{
188 UINT32 orientaion_to_rdp(SDL_DisplayOrientation orientation)
189 {
190 switch (orientation)
191 {
192 case SDL_ORIENTATION_LANDSCAPE:
193 return ORIENTATION_LANDSCAPE;
194 case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
195 return ORIENTATION_LANDSCAPE_FLIPPED;
196 case SDL_ORIENTATION_PORTRAIT_FLIPPED:
197 return ORIENTATION_PORTRAIT_FLIPPED;
198 case SDL_ORIENTATION_PORTRAIT:
199 default:
200 return ORIENTATION_PORTRAIT;
201 }
202 }
203
204 std::string touchFlagsToString(Uint32 flags)
205 {
206 std::stringstream ss;
207 ss << "{";
208 bool first = true;
209 for (size_t x = 0; x < 32; x++)
210 {
211 const Uint32 mask = 1u << x;
212 if (flags & mask)
213 {
214 if (!first)
215 ss << "|";
216 first = false;
217 ss << freerdp_input_touch_state_string(mask);
218 }
219 }
220 ss << "}";
221 return ss.str();
222 }
223
224 std::string toString(SDL_DisplayOrientation orientation)
225 {
226 switch (orientation)
227 {
228 case SDL_ORIENTATION_LANDSCAPE:
229 return "SDL_ORIENTATION_LANDSCAPE";
230 case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
231 return "SDL_ORIENTATION_LANDSCAPE_FLIPPED";
232 case SDL_ORIENTATION_PORTRAIT_FLIPPED:
233 return "SDL_ORIENTATION_PORTRAIT_FLIPPED";
234 case SDL_ORIENTATION_PORTRAIT:
235 return "SDL_ORIENTATION_PORTRAIT";
236 default:
237 {
238 std::stringstream ss;
239 ss << "SDL_ORIENTATION_UNKNOWN[0x" << std::hex << std::setw(8) << std::setfill('0')
240 << orientation << "]";
241 return ss.str();
242 }
243 }
244 }
245
246 std::string toString(FreeRDP_DesktopRotationFlags orientation)
247 {
248 return freerdp_desktop_rotation_flags_to_string(orientation);
249 }
250
251 std::string toString(const SDL_DisplayMode* mode)
252 {
253 if (!mode)
254 return "SDL_DisplayMode=null";
255
256 std::stringstream ss;
257
258 ss << "["
259 << "id=" << mode->displayID << ","
260 << "fmt=" << mode->format << ","
261 << "w=" << mode->w << ","
262 << "h=" << mode->h << ","
263 << "dpi=" << mode->pixel_density << ","
264 << "refresh=" << mode->refresh_rate << ","
265 << "num=" << mode->refresh_rate_numerator << ","
266 << "denom=" << mode->refresh_rate_denominator << "]";
267
268 return ss.str();
269 }
270
271 std::string toString(Uint32 type)
272 {
273 switch (type)
274 {
275 EV_CASE_STR(SDL_EVENT_FIRST);
276 EV_CASE_STR(SDL_EVENT_QUIT);
277 EV_CASE_STR(SDL_EVENT_TERMINATING);
278 EV_CASE_STR(SDL_EVENT_LOW_MEMORY);
279 EV_CASE_STR(SDL_EVENT_WILL_ENTER_BACKGROUND);
280 EV_CASE_STR(SDL_EVENT_DID_ENTER_BACKGROUND);
281 EV_CASE_STR(SDL_EVENT_WILL_ENTER_FOREGROUND);
282 EV_CASE_STR(SDL_EVENT_DID_ENTER_FOREGROUND);
283 EV_CASE_STR(SDL_EVENT_LOCALE_CHANGED);
284 EV_CASE_STR(SDL_EVENT_SYSTEM_THEME_CHANGED);
285 EV_CASE_STR(SDL_EVENT_DISPLAY_ORIENTATION);
286 EV_CASE_STR(SDL_EVENT_DISPLAY_ADDED);
287 EV_CASE_STR(SDL_EVENT_DISPLAY_REMOVED);
288 EV_CASE_STR(SDL_EVENT_DISPLAY_MOVED);
289 EV_CASE_STR(SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED);
290#if SDL_VERSION_ATLEAST(3, 4, 0)
291 EV_CASE_STR(SDL_EVENT_DISPLAY_USABLE_BOUNDS_CHANGED);
292 EV_CASE_STR(SDL_EVENT_SCREEN_KEYBOARD_SHOWN);
293 EV_CASE_STR(SDL_EVENT_SCREEN_KEYBOARD_HIDDEN);
294 EV_CASE_STR(SDL_EVENT_PINCH_BEGIN);
295 EV_CASE_STR(SDL_EVENT_PINCH_UPDATE);
296 EV_CASE_STR(SDL_EVENT_PINCH_END);
297#endif
298#if SDL_VERSION_ATLEAST(3, 4, 22)
299 EV_CASE_STR(SDL_EVENT_WINDOW_SETTINGS_CHANGED);
300 EV_CASE_STR(SDL_EVENT_GAMEPAD_CAPSENSE_TOUCH);
301 EV_CASE_STR(SDL_EVENT_GAMEPAD_CAPSENSE_RELEASE);
302 EV_CASE_STR(SDL_EVENT_NOTIFICATION_ACTION_INVOKED);
303#endif
304 EV_CASE_STR(SDL_EVENT_WINDOW_SHOWN);
305 EV_CASE_STR(SDL_EVENT_WINDOW_HIDDEN);
306 EV_CASE_STR(SDL_EVENT_WINDOW_EXPOSED);
307 EV_CASE_STR(SDL_EVENT_WINDOW_MOVED);
308 EV_CASE_STR(SDL_EVENT_WINDOW_RESIZED);
309 EV_CASE_STR(SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED);
310 EV_CASE_STR(SDL_EVENT_WINDOW_MINIMIZED);
311 EV_CASE_STR(SDL_EVENT_WINDOW_MAXIMIZED);
312 EV_CASE_STR(SDL_EVENT_WINDOW_RESTORED);
313 EV_CASE_STR(SDL_EVENT_WINDOW_MOUSE_ENTER);
314 EV_CASE_STR(SDL_EVENT_WINDOW_MOUSE_LEAVE);
315 EV_CASE_STR(SDL_EVENT_WINDOW_FOCUS_GAINED);
316 EV_CASE_STR(SDL_EVENT_WINDOW_FOCUS_LOST);
317 EV_CASE_STR(SDL_EVENT_WINDOW_CLOSE_REQUESTED);
318 EV_CASE_STR(SDL_EVENT_WINDOW_HIT_TEST);
319 EV_CASE_STR(SDL_EVENT_WINDOW_ICCPROF_CHANGED);
320 EV_CASE_STR(SDL_EVENT_WINDOW_DISPLAY_CHANGED);
321 EV_CASE_STR(SDL_EVENT_WINDOW_SAFE_AREA_CHANGED);
322 EV_CASE_STR(SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED);
323 EV_CASE_STR(SDL_EVENT_WINDOW_OCCLUDED);
324 EV_CASE_STR(SDL_EVENT_WINDOW_ENTER_FULLSCREEN);
325 EV_CASE_STR(SDL_EVENT_WINDOW_LEAVE_FULLSCREEN);
326 EV_CASE_STR(SDL_EVENT_WINDOW_DESTROYED);
327
328 EV_CASE_STR(SDL_EVENT_KEY_DOWN);
329 EV_CASE_STR(SDL_EVENT_KEY_UP);
330 EV_CASE_STR(SDL_EVENT_TEXT_EDITING);
331 EV_CASE_STR(SDL_EVENT_TEXT_INPUT);
332 EV_CASE_STR(SDL_EVENT_KEYMAP_CHANGED);
333 EV_CASE_STR(SDL_EVENT_KEYBOARD_ADDED);
334 EV_CASE_STR(SDL_EVENT_KEYBOARD_REMOVED);
335
336 EV_CASE_STR(SDL_EVENT_MOUSE_MOTION);
337 EV_CASE_STR(SDL_EVENT_MOUSE_BUTTON_DOWN);
338 EV_CASE_STR(SDL_EVENT_MOUSE_BUTTON_UP);
339 EV_CASE_STR(SDL_EVENT_MOUSE_WHEEL);
340 EV_CASE_STR(SDL_EVENT_MOUSE_ADDED);
341 EV_CASE_STR(SDL_EVENT_MOUSE_REMOVED);
342
343 EV_CASE_STR(SDL_EVENT_JOYSTICK_AXIS_MOTION);
344 EV_CASE_STR(SDL_EVENT_JOYSTICK_BALL_MOTION);
345 EV_CASE_STR(SDL_EVENT_JOYSTICK_HAT_MOTION);
346 EV_CASE_STR(SDL_EVENT_JOYSTICK_BUTTON_DOWN);
347 EV_CASE_STR(SDL_EVENT_JOYSTICK_BUTTON_UP);
348 EV_CASE_STR(SDL_EVENT_JOYSTICK_ADDED);
349 EV_CASE_STR(SDL_EVENT_JOYSTICK_REMOVED);
350 EV_CASE_STR(SDL_EVENT_JOYSTICK_BATTERY_UPDATED);
351 EV_CASE_STR(SDL_EVENT_JOYSTICK_UPDATE_COMPLETE);
352
353 EV_CASE_STR(SDL_EVENT_GAMEPAD_AXIS_MOTION);
354 EV_CASE_STR(SDL_EVENT_GAMEPAD_BUTTON_DOWN);
355 EV_CASE_STR(SDL_EVENT_GAMEPAD_BUTTON_UP);
356 EV_CASE_STR(SDL_EVENT_GAMEPAD_ADDED);
357 EV_CASE_STR(SDL_EVENT_GAMEPAD_REMOVED);
358 EV_CASE_STR(SDL_EVENT_GAMEPAD_REMAPPED);
359 EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN);
360 EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION);
361 EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_UP);
362 EV_CASE_STR(SDL_EVENT_GAMEPAD_SENSOR_UPDATE);
363 EV_CASE_STR(SDL_EVENT_GAMEPAD_UPDATE_COMPLETE);
364 EV_CASE_STR(SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED);
365
366 EV_CASE_STR(SDL_EVENT_FINGER_DOWN);
367 EV_CASE_STR(SDL_EVENT_FINGER_UP);
368 EV_CASE_STR(SDL_EVENT_FINGER_MOTION);
369
370 EV_CASE_STR(SDL_EVENT_CLIPBOARD_UPDATE);
371
372 EV_CASE_STR(SDL_EVENT_DROP_FILE);
373 EV_CASE_STR(SDL_EVENT_DROP_TEXT);
374 EV_CASE_STR(SDL_EVENT_DROP_BEGIN);
375 EV_CASE_STR(SDL_EVENT_DROP_COMPLETE);
376 EV_CASE_STR(SDL_EVENT_DROP_POSITION);
377
378 EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_ADDED);
379 EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_REMOVED);
380 EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED);
381
382 EV_CASE_STR(SDL_EVENT_SENSOR_UPDATE);
383
384 EV_CASE_STR(SDL_EVENT_PEN_DOWN);
385 EV_CASE_STR(SDL_EVENT_PEN_UP);
386 EV_CASE_STR(SDL_EVENT_PEN_MOTION);
387 EV_CASE_STR(SDL_EVENT_PEN_BUTTON_DOWN);
388 EV_CASE_STR(SDL_EVENT_PEN_BUTTON_UP);
389 EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_ADDED);
390 EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_REMOVED);
391 EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_APPROVED);
392 EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_DENIED);
393
394 EV_CASE_STR(SDL_EVENT_RENDER_TARGETS_RESET);
395 EV_CASE_STR(SDL_EVENT_RENDER_DEVICE_RESET);
396 EV_CASE_STR(SDL_EVENT_POLL_SENTINEL);
397
398 EV_CASE_STR(SDL_EVENT_USER);
399
400 EV_CASE_STR(SDL_EVENT_USER_CERT_DIALOG);
401 EV_CASE_STR(SDL_EVENT_USER_CERT_RESULT);
402 EV_CASE_STR(SDL_EVENT_USER_SHOW_DIALOG);
403 EV_CASE_STR(SDL_EVENT_USER_SHOW_RESULT);
404 EV_CASE_STR(SDL_EVENT_USER_AUTH_DIALOG);
405 EV_CASE_STR(SDL_EVENT_USER_AUTH_RESULT);
406 EV_CASE_STR(SDL_EVENT_USER_SCARD_DIALOG);
407 EV_CASE_STR(SDL_EVENT_USER_RETRY_DIALOG);
408 EV_CASE_STR(SDL_EVENT_USER_SCARD_RESULT);
409 EV_CASE_STR(SDL_EVENT_USER_RENDERER);
410 EV_CASE_STR(SDL_EVENT_USER_WINDOW_INFO);
411 EV_CASE_STR(SDL_EVENT_USER_UPDATE);
412 EV_CASE_STR(SDL_EVENT_USER_CREATE_WINDOWS);
413 EV_CASE_STR(SDL_EVENT_USER_WINDOW_RESIZEABLE);
414 EV_CASE_STR(SDL_EVENT_USER_WINDOW_FULLSCREEN);
415 EV_CASE_STR(SDL_EVENT_USER_WINDOW_MINIMIZE);
416 EV_CASE_STR(SDL_EVENT_USER_POINTER_NULL);
417 EV_CASE_STR(SDL_EVENT_USER_POINTER_DEFAULT);
418 EV_CASE_STR(SDL_EVENT_USER_POINTER_POSITION);
419 EV_CASE_STR(SDL_EVENT_USER_POINTER_SET);
420 EV_CASE_STR(SDL_EVENT_USER_RAIL_MOVE);
421 EV_CASE_STR(SDL_EVENT_USER_OVERLAY);
422 EV_CASE_STR(SDL_EVENT_USER_QUIT);
423
424 EV_CASE_STR(SDL_EVENT_LAST);
425 default:
426 {
427 std::stringstream ss;
428 ss << "SDL_UNKNOWNEVENT[0x" << std::hex << std::setw(8) << std::setfill('0') << type
429 << "]";
430 return ss.str();
431 }
432 }
433 }
434
435 std::string generate_uuid_v4()
436 {
437 static std::random_device rd;
438 static std::mt19937 gen(rd());
439 static std::uniform_int_distribution<> dis(0, 255);
440 std::stringstream ss;
441 ss << std::hex << std::setfill('0') << std::setw(2);
442 for (int i = 0; i < 4; i++)
443 {
444 ss << dis(gen);
445 }
446 ss << "-";
447 for (int i = 0; i < 2; i++)
448 {
449 ss << dis(gen);
450 }
451 ss << "-";
452 for (int i = 0; i < 2; i++)
453 {
454 ss << dis(gen);
455 }
456 ss << "-";
457 for (int i = 0; i < 2; i++)
458 {
459 ss << dis(gen);
460 }
461 ss << "-";
462 for (int i = 0; i < 6; i++)
463 {
464 ss << dis(gen);
465 }
466 return ss.str();
467 }
468
469 HighDpiScaleMode platformScaleMode()
470 {
471 const auto platform = SDL_GetPlatform();
472 if (!platform)
473 return SCALE_MODE_INVALID;
474 if (strcmp("Windows", platform) == 0)
475 return SCALE_MODE_X11;
476 if (strcmp("macOS", platform) == 0)
477 return SCALE_MODE_WAYLAND;
478 if (strcmp("Linux", platform) == 0)
479 {
480 const auto driver = SDL_GetCurrentVideoDriver();
481 if (!driver)
482 return SCALE_MODE_WAYLAND;
483 if (strcmp("x11", driver) == 0)
484 return SCALE_MODE_X11;
485 if (strcmp("wayland", driver) == 0)
486 return SCALE_MODE_WAYLAND;
487 }
488 return SCALE_MODE_INVALID;
489 }
490
491 static bool isVideoDriver(const char* name)
492 {
493 const auto driver = SDL_GetCurrentVideoDriver();
494 return driver && name && (strcmp(driver, name) == 0);
495 }
496
497 bool isWaylandDriver()
498 {
499 return isVideoDriver("wayland");
500 }
501
502 bool isX11Driver()
503 {
504 return isVideoDriver("x11");
505 }
506
507 bool isWindowsDriver()
508 {
509 return isVideoDriver("windows");
510 }
511
512 std::string windowTitle(const rdpSettings* settings)
513 {
514 const char* prefix = "FreeRDP:";
515
516 if (!settings)
517 return {};
518
519 const auto windowTitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
520 if (windowTitle)
521 return {};
522
523 const auto name = freerdp_settings_get_server_name(settings);
524 const auto port = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
525
526 const auto addPort = (port != 3389);
527
528 std::stringstream ss;
529 ss << prefix << " ";
530 if (!addPort)
531 ss << name;
532 else
533 ss << name << ":" << port;
534
535 return ss.str();
536 }
537
538 std::string toString(SDL_Rect rect)
539 {
540 std::stringstream ss;
541 ss << "SDL_Rect{" << rect.x << "x" << rect.y << "-" << rect.w << "x" << rect.h << "}";
542 return ss.str();
543 }
544
545 std::string toString(SDL_FRect rect)
546 {
547 std::stringstream ss;
548 ss << "SDL_Rect{" << rect.x << "x" << rect.y << "-" << rect.w << "x" << rect.h << "}";
549 return ss.str();
550 }
551
552 bool inputSent(rdpContext* context, wLog* log, BOOL sent, const char* what)
553 {
554 if (sent)
555 return true;
556 if (freerdp_is_active_state(context))
557 return false;
558 WLog_Print(log, WLOG_DEBUG, "%s not sent, the connection is lost: the event is dropped",
559 what);
560 return true;
561 }
562
563} // namespace sdl::utils
564
565namespace sdl::error
566{
567 struct sdl_exitCode_map_t
568 {
569 DWORD error;
570 int code;
571 const char* code_tag;
572 };
573
574#define ENTRY(x, y) { x, y, #y }
575 static const struct sdl_exitCode_map_t sdl_exitCode_map[] = {
576 ENTRY(FREERDP_ERROR_SUCCESS, SUCCESS), ENTRY(ERRINFO_RPC_INITIATED_DISCONNECT, DISCONNECT),
577 ENTRY(ERRINFO_RPC_INITIATED_LOGOFF, LOGOFF), ENTRY(ERRINFO_IDLE_TIMEOUT, IDLE_TIMEOUT),
578 ENTRY(ERRINFO_LOGON_TIMEOUT, LOGON_TIMEOUT),
579 ENTRY(ERRINFO_DISCONNECTED_BY_OTHER_CONNECTION, CONN_REPLACED),
580 ENTRY(ERRINFO_OUT_OF_MEMORY, OUT_OF_MEMORY),
581 ENTRY(ERRINFO_SERVER_DENIED_CONNECTION, CONN_DENIED),
582 ENTRY(FREERDP_ERROR_NONE, CONN_DENIED_FIPS),
583 ENTRY(ERRINFO_SERVER_INSUFFICIENT_PRIVILEGES, USER_PRIVILEGES),
584 ENTRY(ERRINFO_SERVER_FRESH_CREDENTIALS_REQUIRED, FRESH_CREDENTIALS_REQUIRED),
585 ENTRY(ERRINFO_RPC_INITIATED_DISCONNECT_BY_USER, DISCONNECT_BY_USER),
586 ENTRY(ERRINFO_LOGOFF_BY_USER, DISCONNECT_BY_USER), ENTRY(FREERDP_ERROR_NONE, UNKNOWN),
587
588 /* section 16-31: license error set */
589 ENTRY(ERRINFO_LICENSE_INTERNAL, LICENSE_INTERNAL),
590 ENTRY(ERRINFO_LICENSE_NO_LICENSE_SERVER, LICENSE_NO_LICENSE_SERVER),
591 ENTRY(ERRINFO_LICENSE_NO_LICENSE, LICENSE_NO_LICENSE),
592 ENTRY(ERRINFO_LICENSE_BAD_CLIENT_MSG, LICENSE_BAD_CLIENT_MSG),
593 ENTRY(ERRINFO_LICENSE_HWID_DOESNT_MATCH_LICENSE, LICENSE_HWID_DOESNT_MATCH),
594 ENTRY(ERRINFO_LICENSE_BAD_CLIENT_LICENSE, LICENSE_BAD_CLIENT),
595 ENTRY(ERRINFO_LICENSE_CANT_FINISH_PROTOCOL, LICENSE_CANT_FINISH_PROTOCOL),
596 ENTRY(ERRINFO_LICENSE_CLIENT_ENDED_PROTOCOL, LICENSE_CLIENT_ENDED_PROTOCOL),
597 ENTRY(ERRINFO_LICENSE_BAD_CLIENT_ENCRYPTION, LICENSE_BAD_CLIENT_ENCRYPTION),
598 ENTRY(ERRINFO_LICENSE_CANT_UPGRADE_LICENSE, LICENSE_CANT_UPGRADE),
599 ENTRY(ERRINFO_LICENSE_NO_REMOTE_CONNECTIONS, LICENSE_NO_REMOTE_CONNECTIONS),
600
601 /* section 32-127: RDP protocol error set */
602 ENTRY(FREERDP_ERROR_NONE, RDP),
603
604 /* section 128-254: xfreerdp specific exit codes */
605 ENTRY(FREERDP_ERROR_NONE, PARSE_ARGUMENTS), ENTRY(FREERDP_ERROR_NONE, MEMORY),
606 ENTRY(FREERDP_ERROR_NONE, PROTOCOL), ENTRY(FREERDP_ERROR_NONE, CONN_FAILED),
607
608 ENTRY(FREERDP_ERROR_AUTHENTICATION_FAILED, AUTH_FAILURE),
609 ENTRY(FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED, NEGO_FAILURE),
610 ENTRY(FREERDP_ERROR_CONNECT_LOGON_FAILURE, LOGON_FAILURE),
611 ENTRY(FREERDP_ERROR_CONNECT_TARGET_BOOTING, CONNECT_TARGET_BOOTING),
612 ENTRY(FREERDP_ERROR_CONNECT_HYBRID_REQUIRED_BY_SERVER, CONNECT_HYBRID_REQUIRED_BY_SERVER),
613 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_LOCKED_OUT, ACCOUNT_LOCKED_OUT),
614 ENTRY(FREERDP_ERROR_PRE_CONNECT_FAILED, PRE_CONNECT_FAILED),
615 ENTRY(FREERDP_ERROR_CONNECT_UNDEFINED, CONNECT_UNDEFINED),
616 ENTRY(FREERDP_ERROR_POST_CONNECT_FAILED, POST_CONNECT_FAILED),
617 ENTRY(FREERDP_ERROR_DNS_ERROR, DNS_ERROR),
618 ENTRY(FREERDP_ERROR_DNS_NAME_NOT_FOUND, DNS_NAME_NOT_FOUND),
619 ENTRY(FREERDP_ERROR_CONNECT_FAILED, CONNECT_FAILED),
620 ENTRY(FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR, MCS_CONNECT_INITIAL_ERROR),
621 ENTRY(FREERDP_ERROR_TLS_CONNECT_FAILED, TLS_CONNECT_FAILED),
622 ENTRY(FREERDP_ERROR_INSUFFICIENT_PRIVILEGES, INSUFFICIENT_PRIVILEGES),
623 ENTRY(FREERDP_ERROR_CONNECT_CANCELLED, CONNECT_CANCELLED),
624 ENTRY(FREERDP_ERROR_CONNECT_TRANSPORT_FAILED, CONNECT_TRANSPORT_FAILED),
625 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_EXPIRED, CONNECT_PASSWORD_EXPIRED),
626 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_MUST_CHANGE, CONNECT_PASSWORD_MUST_CHANGE),
627 ENTRY(FREERDP_ERROR_CONNECT_KDC_UNREACHABLE, CONNECT_KDC_UNREACHABLE),
628 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_DISABLED, CONNECT_ACCOUNT_DISABLED),
629 ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_CERTAINLY_EXPIRED, CONNECT_PASSWORD_CERTAINLY_EXPIRED),
630 ENTRY(FREERDP_ERROR_CONNECT_CLIENT_REVOKED, CONNECT_CLIENT_REVOKED),
631 ENTRY(FREERDP_ERROR_CONNECT_WRONG_PASSWORD, CONNECT_WRONG_PASSWORD),
632 ENTRY(FREERDP_ERROR_CONNECT_ACCESS_DENIED, CONNECT_ACCESS_DENIED),
633 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_RESTRICTION, CONNECT_ACCOUNT_RESTRICTION),
634 ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_EXPIRED, CONNECT_ACCOUNT_EXPIRED),
635 ENTRY(FREERDP_ERROR_CONNECT_LOGON_TYPE_NOT_GRANTED, CONNECT_LOGON_TYPE_NOT_GRANTED),
636 ENTRY(FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS, CONNECT_NO_OR_MISSING_CREDENTIALS)
637 };
638
639 static const sdl_exitCode_map_t* mapEntryByCode(int exit_code)
640 {
641 for (const auto& x : sdl_exitCode_map)
642 {
643 auto cur = &x;
644 if (cur->code == exit_code)
645 return cur;
646 }
647 return nullptr;
648 }
649
650 static const sdl_exitCode_map_t* mapEntryByError(UINT32 error)
651 {
652 for (const auto& x : sdl_exitCode_map)
653 {
654 auto cur = &x;
655 if (cur->error == error)
656 return cur;
657 }
658 return nullptr;
659 }
660
661 int errorToExitCode(DWORD error)
662 {
663 auto entry = mapEntryByError(error);
664 if (entry)
665 return entry->code;
666
667 return CONN_FAILED;
668 }
669
670 const char* errorToExitCodeTag(UINT32 error)
671 {
672 return exitCodeToTag(errorToExitCode(error));
673 }
674
675 const char* exitCodeToTag(int code)
676 {
677 auto entry = mapEntryByCode(code);
678 if (entry)
679 return entry->code_tag;
680 return nullptr;
681 }
682} // namespace sdl::error
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_server_name(const rdpSettings *settings)
A helper function to return the correct server name.
WINPR_ATTR_NODISCARD FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.