SDL2/sdl_freerdp.cpp

 
#include <memory>
#include <mutex>
#include <iostream>
 
#include <freerdp/config.h>
 
#include <cerrno>
#include <cstdio>
#include <cstring>
 
#include <freerdp/freerdp.h>
#include <freerdp/constants.h>
#include <freerdp/gdi/gdi.h>
#include <freerdp/streamdump.h>
#include <freerdp/utils/signal.h>
 
#include <freerdp/client/file.h>
#include <freerdp/client/cmdline.h>
#include <freerdp/client/cliprdr.h>
#include <freerdp/client/channels.h>
#include <freerdp/client/aad_helper.h>
#include <freerdp/channels/channels.h>
 
#include <winpr/crt.h>
#include <winpr/config.h>
#include <winpr/assert.h>
#include <winpr/synch.h>
#include <freerdp/log.h>
 
#include <SDL.h>
#include <SDL_hints.h>
#include <SDL_video.h>
 
#include "sdl_channels.hpp"
#include "sdl_freerdp.hpp"
#include "sdl_utils.hpp"
#include "sdl_disp.hpp"
#include "sdl_monitor.hpp"
#include "sdl_kbd.hpp"
#include "sdl_touch.hpp"
#include "sdl_pointer.hpp"
#include "sdl_prefs.hpp"
#include "dialogs/sdl_dialogs.hpp"
#include "scoped_guard.hpp"
#if defined(_WIN32)
#include "sdl_win32_console.hpp"
#endif
 
#include <sdl_config.hpp>
 
#define SDL_TAG CLIENT_TAG("SDL")
 
enum SDL_EXIT_CODE
{
  /* section 0-15: protocol-independent codes */
  SDL_EXIT_SUCCESS = 0,
  SDL_EXIT_DISCONNECT = 1,
  SDL_EXIT_LOGOFF = 2,
  SDL_EXIT_IDLE_TIMEOUT = 3,
  SDL_EXIT_LOGON_TIMEOUT = 4,
  SDL_EXIT_CONN_REPLACED = 5,
  SDL_EXIT_OUT_OF_MEMORY = 6,
  SDL_EXIT_CONN_DENIED = 7,
  SDL_EXIT_CONN_DENIED_FIPS = 8,
  SDL_EXIT_USER_PRIVILEGES = 9,
  SDL_EXIT_FRESH_CREDENTIALS_REQUIRED = 10,
  SDL_EXIT_DISCONNECT_BY_USER = 11,
 
  /* section 16-31: license error set */
  SDL_EXIT_LICENSE_INTERNAL = 16,
  SDL_EXIT_LICENSE_NO_LICENSE_SERVER = 17,
  SDL_EXIT_LICENSE_NO_LICENSE = 18,
  SDL_EXIT_LICENSE_BAD_CLIENT_MSG = 19,
  SDL_EXIT_LICENSE_HWID_DOESNT_MATCH = 20,
  SDL_EXIT_LICENSE_BAD_CLIENT = 21,
  SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL = 22,
  SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL = 23,
  SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION = 24,
  SDL_EXIT_LICENSE_CANT_UPGRADE = 25,
  SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS = 26,
 
  /* section 32-127: RDP protocol error set */
  SDL_EXIT_RDP = 32,
 
  /* section 128-254: xfreerdp specific exit codes */
  SDL_EXIT_PARSE_ARGUMENTS = 128,
  SDL_EXIT_MEMORY = 129,
  SDL_EXIT_PROTOCOL = 130,
  SDL_EXIT_CONN_FAILED = 131,
  SDL_EXIT_AUTH_FAILURE = 132,
  SDL_EXIT_NEGO_FAILURE = 133,
  SDL_EXIT_LOGON_FAILURE = 134,
  SDL_EXIT_ACCOUNT_LOCKED_OUT = 135,
  SDL_EXIT_PRE_CONNECT_FAILED = 136,
  SDL_EXIT_CONNECT_UNDEFINED = 137,
  SDL_EXIT_POST_CONNECT_FAILED = 138,
  SDL_EXIT_DNS_ERROR = 139,
  SDL_EXIT_DNS_NAME_NOT_FOUND = 140,
  SDL_EXIT_CONNECT_FAILED = 141,
  SDL_EXIT_MCS_CONNECT_INITIAL_ERROR = 142,
  SDL_EXIT_TLS_CONNECT_FAILED = 143,
  SDL_EXIT_INSUFFICIENT_PRIVILEGES = 144,
  SDL_EXIT_CONNECT_CANCELLED = 145,
 
  SDL_EXIT_CONNECT_TRANSPORT_FAILED = 147,
  SDL_EXIT_CONNECT_PASSWORD_EXPIRED = 148,
  SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE = 149,
  SDL_EXIT_CONNECT_KDC_UNREACHABLE = 150,
  SDL_EXIT_CONNECT_ACCOUNT_DISABLED = 151,
  SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED = 152,
  SDL_EXIT_CONNECT_CLIENT_REVOKED = 153,
  SDL_EXIT_CONNECT_WRONG_PASSWORD = 154,
  SDL_EXIT_CONNECT_ACCESS_DENIED = 155,
  SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION = 156,
  SDL_EXIT_CONNECT_ACCOUNT_EXPIRED = 157,
  SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED = 158,
  SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS = 159,
 
  SDL_EXIT_UNKNOWN = 255,
};
 
struct sdl_exit_code_map_t
{
  UINT32 error;
  int code;
  const char* code_tag;
};
 
#define ENTRY(x, y) { x, y, #y }
static const struct sdl_exit_code_map_t sdl_exit_code_map[] = {
  ENTRY(FREERDP_ERROR_SUCCESS, SDL_EXIT_SUCCESS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_DISCONNECT),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGOFF), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_IDLE_TIMEOUT),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGON_TIMEOUT),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_REPLACED),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_OUT_OF_MEMORY),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED_FIPS),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_USER_PRIVILEGES),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_FRESH_CREDENTIALS_REQUIRED),
  ENTRY(ERRINFO_LOGOFF_BY_USER, SDL_EXIT_DISCONNECT_BY_USER),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_UNKNOWN),
 
  /* section 16-31: license error set */
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_INTERNAL),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE_SERVER),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_MSG),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_HWID_DOESNT_MATCH),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
 
  /* section 32-127: RDP protocol error set */
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_RDP),
 
  /* section 128-254: xfreerdp specific exit codes */
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PARSE_ARGUMENTS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_MEMORY),
  ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PROTOCOL), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_FAILED),
 
  ENTRY(FREERDP_ERROR_AUTHENTICATION_FAILED, SDL_EXIT_AUTH_FAILURE),
  ENTRY(FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED, SDL_EXIT_NEGO_FAILURE),
  ENTRY(FREERDP_ERROR_CONNECT_LOGON_FAILURE, SDL_EXIT_LOGON_FAILURE),
  ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_LOCKED_OUT, SDL_EXIT_ACCOUNT_LOCKED_OUT),
  ENTRY(FREERDP_ERROR_PRE_CONNECT_FAILED, SDL_EXIT_PRE_CONNECT_FAILED),
  ENTRY(FREERDP_ERROR_CONNECT_UNDEFINED, SDL_EXIT_CONNECT_UNDEFINED),
  ENTRY(FREERDP_ERROR_POST_CONNECT_FAILED, SDL_EXIT_POST_CONNECT_FAILED),
  ENTRY(FREERDP_ERROR_DNS_ERROR, SDL_EXIT_DNS_ERROR),
  ENTRY(FREERDP_ERROR_DNS_NAME_NOT_FOUND, SDL_EXIT_DNS_NAME_NOT_FOUND),
  ENTRY(FREERDP_ERROR_CONNECT_FAILED, SDL_EXIT_CONNECT_FAILED),
  ENTRY(FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR, SDL_EXIT_MCS_CONNECT_INITIAL_ERROR),
  ENTRY(FREERDP_ERROR_TLS_CONNECT_FAILED, SDL_EXIT_TLS_CONNECT_FAILED),
  ENTRY(FREERDP_ERROR_INSUFFICIENT_PRIVILEGES, SDL_EXIT_INSUFFICIENT_PRIVILEGES),
  ENTRY(FREERDP_ERROR_CONNECT_CANCELLED, SDL_EXIT_CONNECT_CANCELLED),
  ENTRY(FREERDP_ERROR_CONNECT_TRANSPORT_FAILED, SDL_EXIT_CONNECT_TRANSPORT_FAILED),
  ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_EXPIRED, SDL_EXIT_CONNECT_PASSWORD_EXPIRED),
  ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_MUST_CHANGE, SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE),
  ENTRY(FREERDP_ERROR_CONNECT_KDC_UNREACHABLE, SDL_EXIT_CONNECT_KDC_UNREACHABLE),
  ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_DISABLED, SDL_EXIT_CONNECT_ACCOUNT_DISABLED),
  ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_CERTAINLY_EXPIRED,
        SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED),
  ENTRY(FREERDP_ERROR_CONNECT_CLIENT_REVOKED, SDL_EXIT_CONNECT_CLIENT_REVOKED),
  ENTRY(FREERDP_ERROR_CONNECT_WRONG_PASSWORD, SDL_EXIT_CONNECT_WRONG_PASSWORD),
  ENTRY(FREERDP_ERROR_CONNECT_ACCESS_DENIED, SDL_EXIT_CONNECT_ACCESS_DENIED),
  ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_RESTRICTION, SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION),
  ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_EXPIRED, SDL_EXIT_CONNECT_ACCOUNT_EXPIRED),
  ENTRY(FREERDP_ERROR_CONNECT_LOGON_TYPE_NOT_GRANTED, SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED),
  ENTRY(FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS,
        SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS)
};
 
static const struct sdl_exit_code_map_t* sdl_map_entry_by_code(int exit_code)
{
  for (const auto& x : sdl_exit_code_map)
  {
    const struct sdl_exit_code_map_t* cur = &x;
    if (cur->code == exit_code)
      return cur;
  }
  return nullptr;
}
 
static void sdl_hide_connection_dialog(SdlContext* sdl)
{
  WINPR_ASSERT(sdl);
  std::scoped_lock lock(sdl->critical);
  if (sdl->connection_dialog)
    sdl->connection_dialog->hide();
}
 
static const struct sdl_exit_code_map_t* sdl_map_entry_by_error(UINT32 error)
{
  for (const auto& x : sdl_exit_code_map)
  {
    const struct sdl_exit_code_map_t* cur = &x;
    if (cur->error == static_cast<uint32_t>(error))
      return cur;
  }
  return nullptr;
}
 
static int sdl_map_error_to_exit_code(UINT32 error)
{
  const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
  if (entry)
    return entry->code;
 
  return SDL_EXIT_CONN_FAILED;
}
 
static const char* sdl_map_error_to_code_tag(UINT32 error)
{
  const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
  if (entry)
    return entry->code_tag;
  return nullptr;
}
 
static const char* sdl_map_to_code_tag(int code)
{
  const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_code(code);
  if (entry)
    return entry->code_tag;
  return nullptr;
}
 
static int error_info_to_error(freerdp* instance, DWORD* pcode, char** msg, size_t* len)
{
  const DWORD code = freerdp_error_info(instance);
  const char* name = freerdp_get_error_info_name(code);
  const char* str = freerdp_get_error_info_string(code);
  const int exit_code = sdl_map_error_to_exit_code(code);
 
  winpr_asprintf(msg, len, "Terminate with %s due to ERROR_INFO %s [0x%08" PRIx32 "]: %s",
                 sdl_map_error_to_code_tag(code), name, code, str);
  WLog_DBG(SDL_TAG, "%s", *msg);
  if (pcode)
    *pcode = code;
  return exit_code;
}
 
/* This function is called whenever a new frame starts.
 * It can be used to reset invalidated areas. */
static BOOL sdl_begin_paint(rdpContext* context)
{
  auto sdl = get_context(context);
 
  WINPR_ASSERT(sdl);
 
  HANDLE handles[] = { sdl->update_complete.handle(), freerdp_abort_event(context) };
  const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
  switch (status)
  {
    case WAIT_OBJECT_0:
      break;
    default:
      return FALSE;
  }
  sdl->update_complete.clear();
 
  auto gdi = context->gdi;
  WINPR_ASSERT(gdi);
  WINPR_ASSERT(gdi->primary);
 
  HGDI_DC hdc = gdi->primary->hdc;
  WINPR_ASSERT(hdc);
  if (!hdc->hwnd)
    return TRUE;
 
  HGDI_WND hwnd = hdc->hwnd;
  WINPR_ASSERT(hwnd->invalid);
  hwnd->invalid->null = TRUE;
  hwnd->ninvalid = 0;
 
  return TRUE;
}
 
static BOOL sdl_redraw(SdlContext* sdl)
{
  WINPR_ASSERT(sdl);
 
  auto gdi = sdl->context()->gdi;
  return gdi_send_suppress_output(gdi, FALSE);
}
 
class SdlEventUpdateTriggerGuard
{
  private:
  SdlContext* _sdl;
 
  public:
  explicit SdlEventUpdateTriggerGuard(SdlContext* sdl) : _sdl(sdl)
  {
  }
  ~SdlEventUpdateTriggerGuard()
  {
    _sdl->update_complete.set();
  }
  SdlEventUpdateTriggerGuard(const SdlEventUpdateTriggerGuard&) = delete;
  SdlEventUpdateTriggerGuard(SdlEventUpdateTriggerGuard&&) = delete;
  SdlEventUpdateTriggerGuard& operator=(const SdlEventUpdateTriggerGuard&) = delete;
  SdlEventUpdateTriggerGuard& operator=(SdlEventUpdateTriggerGuard&&) = delete;
};
 
static bool sdl_draw_to_window_rect([[maybe_unused]] SdlContext* sdl, SdlWindow& window,
                                    SDL_Surface* surface, SDL_Point offset, SDL_Rect srcRect)
{
  SDL_Rect dstRect = { offset.x + srcRect.x, offset.y + srcRect.y, srcRect.w, srcRect.h };
  return window.blit(surface, srcRect, dstRect);
}
 
static bool sdl_draw_to_window_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
                                    SDL_Point offset, const std::vector<SDL_Rect>& rects = {})
{
  if (rects.empty())
  {
    return sdl_draw_to_window_rect(sdl, window, surface, offset,
                                   { 0, 0, surface->w, surface->h });
  }
  for (auto& srcRect : rects)
  {
    if (!sdl_draw_to_window_rect(sdl, window, surface, offset, srcRect))
      return false;
  }
  return true;
}
 
static bool sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
                                           SDL_Rect srcRect)
{
  SDL_Rect dstRect = srcRect;
  sdl_scale_coordinates(sdl, window.id(), &dstRect.x, &dstRect.y, FALSE, TRUE);
  sdl_scale_coordinates(sdl, window.id(), &dstRect.w, &dstRect.h, FALSE, TRUE);
  return window.blit(surface, srcRect, dstRect);
}
 
static BOOL sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
                                           const std::vector<SDL_Rect>& rects = {})
{
  if (rects.empty())
  {
    return sdl_draw_to_window_scaled_rect(sdl, window, surface,
                                          { 0, 0, surface->w, surface->h });
  }
  for (const auto& srcRect : rects)
  {
    if (!sdl_draw_to_window_scaled_rect(sdl, window, surface, srcRect))
      return FALSE;
  }
  return TRUE;
}
 
static BOOL sdl_draw_to_window(SdlContext* sdl, SdlWindow& window,
                               const std::vector<SDL_Rect>& rects = {})
{
  WINPR_ASSERT(sdl);
 
  auto context = sdl->context();
  auto gdi = context->gdi;
 
  auto size = window.rect();
 
  if (!freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing))
  {
    if (gdi->width < size.w)
    {
      window.setOffsetX((size.w - gdi->width) / 2);
    }
    if (gdi->height < size.h)
    {
      window.setOffsetY((size.h - gdi->height) / 2);
    }
 
    auto surface = sdl->primary.get();
    if (!sdl_draw_to_window_rect(sdl, window, surface, { window.offsetX(), window.offsetY() },
                                 rects))
      return FALSE;
  }
  else
  {
    if (!sdl_draw_to_window_scaled_rect(sdl, window, sdl->primary.get(), rects))
      return FALSE;
  }
  window.updateSurface();
  return TRUE;
}
 
static BOOL sdl_draw_to_window(SdlContext* sdl, std::map<Uint32, SdlWindow>& windows,
                               const std::vector<SDL_Rect>& rects = {})
{
  for (auto& window : windows)
  {
    if (!sdl_draw_to_window(sdl, window.second, rects))
      return FALSE;
  }
 
  return TRUE;
}
 
static BOOL sdl_end_paint_process(rdpContext* context)
{
  auto sdl = get_context(context);
 
  WINPR_ASSERT(context);
 
  SdlEventUpdateTriggerGuard guard(sdl);
 
  auto gdi = context->gdi;
  WINPR_ASSERT(gdi);
  WINPR_ASSERT(gdi->primary);
 
  HGDI_DC hdc = gdi->primary->hdc;
  WINPR_ASSERT(hdc);
  if (!hdc->hwnd)
    return TRUE;
 
  HGDI_WND hwnd = hdc->hwnd;
  WINPR_ASSERT(hwnd->invalid || (hwnd->ninvalid == 0));
 
  if (hwnd->invalid->null)
    return TRUE;
 
  WINPR_ASSERT(hwnd->invalid);
  if (gdi->suppressOutput || hwnd->invalid->null)
    return TRUE;
 
  const INT32 ninvalid = hwnd->ninvalid;
  const GDI_RGN* cinvalid = hwnd->cinvalid;
 
  if (ninvalid < 1)
    return TRUE;
 
  std::vector<SDL_Rect> rects;
  for (INT32 x = 0; x < ninvalid; x++)
  {
    auto& rgn = cinvalid[x];
    rects.push_back({ rgn.x, rgn.y, rgn.w, rgn.h });
  }
 
  return sdl_draw_to_window(sdl, sdl->windows, rects);
}
 
/* This function is called when the library completed composing a new
 * frame. Read out the changed areas and blit them to your output device.
 * The image buffer will have the format specified by gdi_init
 */
static BOOL sdl_end_paint(rdpContext* context)
{
  auto sdl = get_context(context);
  WINPR_ASSERT(sdl);
 
  std::scoped_lock lock(sdl->critical);
  const BOOL rc = sdl_push_user_event(SDL_USEREVENT_UPDATE, context);
 
  return rc;
}
 
static void sdl_destroy_primary(SdlContext* sdl)
{
  if (!sdl)
    return;
  sdl->primary.reset();
  sdl->primary_format.reset();
}
 
/* Create a SDL surface from the GDI buffer */
static BOOL sdl_create_primary(SdlContext* sdl)
{
  rdpGdi* gdi = nullptr;
 
  WINPR_ASSERT(sdl);
 
  gdi = sdl->context()->gdi;
  WINPR_ASSERT(gdi);
 
  sdl_destroy_primary(sdl);
  sdl->primary = SDLSurfacePtr(
      SDL_CreateRGBSurfaceWithFormatFrom(gdi->primary_buffer, static_cast<int>(gdi->width),
                                         static_cast<int>(gdi->height),
                                         static_cast<int>(FreeRDPGetBitsPerPixel(gdi->dstFormat)),
                                         static_cast<int>(gdi->stride), sdl->sdl_pixel_format),
      SDL_FreeSurface);
  sdl->primary_format = SDLPixelFormatPtr(SDL_AllocFormat(sdl->sdl_pixel_format), SDL_FreeFormat);
 
  if (!sdl->primary || !sdl->primary_format)
    return FALSE;
 
  SDL_SetSurfaceBlendMode(sdl->primary.get(), SDL_BLENDMODE_NONE);
  SDL_FillRect(sdl->primary.get(), nullptr,
               SDL_MapRGBA(sdl->primary_format.get(), 0, 0, 0, 0xff));
 
  return TRUE;
}
 
static BOOL sdl_desktop_resize(rdpContext* context)
{
  rdpGdi* gdi = nullptr;
  rdpSettings* settings = nullptr;
  auto sdl = get_context(context);
 
  WINPR_ASSERT(sdl);
  WINPR_ASSERT(context);
 
  settings = context->settings;
  WINPR_ASSERT(settings);
 
  std::scoped_lock lock(sdl->critical);
  gdi = context->gdi;
  if (!gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
                  freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
    return FALSE;
  return sdl_create_primary(sdl);
}
 
/* This function is called to output a System BEEP */
static BOOL sdl_play_sound(rdpContext* context, const PLAY_SOUND_UPDATE* play_sound)
{
  /* TODO: Implement */
  WINPR_UNUSED(context);
  WINPR_UNUSED(play_sound);
  return TRUE;
}
 
static BOOL sdl_wait_for_init(SdlContext* sdl)
{
  WINPR_ASSERT(sdl);
  sdl->initialize.set();
 
  HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
 
  const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
  switch (rc)
  {
    case WAIT_OBJECT_0:
      return TRUE;
    default:
      return FALSE;
  }
}
 
/* Called before a connection is established.
 * Set all configuration options to support and load channels here. */
static BOOL sdl_pre_connect(freerdp* instance)
{
  WINPR_ASSERT(instance);
  WINPR_ASSERT(instance->context);
 
  auto sdl = get_context(instance->context);
 
  auto settings = instance->context->settings;
  WINPR_ASSERT(settings);
 
  if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
    return FALSE;
 
  /* Optional OS identifier sent to server */
  if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
    return FALSE;
  if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_SDL))
    return FALSE;
  /* OrderSupport is initialized at this point.
   * Only override it if you plan to implement custom order
   * callbacks or deactivate certain features. */
  /* Register the channel listeners.
   * They are required to set up / tear down channels if they are loaded. */
  if (PubSub_SubscribeChannelConnected(instance->context->pubSub,
                                       sdl_OnChannelConnectedEventHandler) < 0)
    return FALSE;
  if (PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
                                          sdl_OnChannelDisconnectedEventHandler) < 0)
    return FALSE;
  if (PubSub_SubscribeUserNotification(instance->context->pubSub,
                                       sdl_OnUserNotificationEventHandler) < 0)
    return FALSE;
 
  if (!freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
  {
    UINT32 maxWidth = 0;
    UINT32 maxHeight = 0;
 
    if (!sdl_wait_for_init(sdl))
      return FALSE;
 
    std::scoped_lock lock(sdl->critical);
    if (!freerdp_settings_get_bool(settings, FreeRDP_UseCommonStdioCallbacks))
      sdl->connection_dialog = std::make_unique<SDLConnectionDialog>(instance->context);
    if (sdl->connection_dialog)
    {
      sdl->connection_dialog->setTitle("Connecting to '%s'",
                                       freerdp_settings_get_server_name(settings));
      sdl->connection_dialog->showInfo(
          "The connection is being established\n\nPlease wait...");
    }
    if (!sdl_detect_monitors(sdl, &maxWidth, &maxHeight))
      return FALSE;
 
    if ((maxWidth != 0) && (maxHeight != 0) &&
        !freerdp_settings_get_bool(settings, FreeRDP_SmartSizing))
    {
      WLog_Print(sdl->log, WLOG_INFO, "Update size to %ux%u", maxWidth, maxHeight);
      if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, maxWidth))
        return FALSE;
      if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, maxHeight))
        return FALSE;
    }
  }
  else
  {
    /* Check +auth-only has a username and password. */
    if (!freerdp_settings_get_string(settings, FreeRDP_Password))
    {
      WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
      return FALSE;
    }
 
    if (!freerdp_settings_set_bool(settings, FreeRDP_DeactivateClientDecoding, TRUE))
      return FALSE;
 
    WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect SDL.");
  }
 
  /* TODO: Any code your client requires */
  return TRUE;
}
 
static const char* sdl_window_get_title(rdpSettings* settings)
{
  const char* windowTitle = nullptr;
  UINT32 port = 0;
  BOOL addPort = 0;
  const char* name = nullptr;
  const char* prefix = "FreeRDP:";
 
  if (!settings)
    return nullptr;
 
  windowTitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
  if (windowTitle)
    return windowTitle;
 
  name = freerdp_settings_get_server_name(settings);
  port = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
 
  addPort = (port != 3389);
 
  char buffer[MAX_PATH + 64] = {};
 
  if (!addPort)
    (void)sprintf_s(buffer, sizeof(buffer), "%s %s", prefix, name);
  else
    (void)sprintf_s(buffer, sizeof(buffer), "%s %s:%" PRIu32, prefix, name, port);
 
  if (!freerdp_settings_set_string(settings, FreeRDP_WindowTitle, buffer))
    return nullptr;
  return freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
}
 
static void sdl_term_handler([[maybe_unused]] int signum, [[maybe_unused]] const char* signame,
                             [[maybe_unused]] void* context)
{
  sdl_push_quit();
}
 
static void sdl_cleanup_sdl(SdlContext* sdl)
{
  if (!sdl)
    return;
 
  std::scoped_lock lock(sdl->critical);
  sdl->windows.clear();
  sdl->connection_dialog.reset();
 
  sdl_destroy_primary(sdl);
 
  freerdp_del_signal_cleanup_handler(sdl->context(), sdl_term_handler);
  TTF_Quit();
  SDL_Quit();
}
 
static BOOL sdl_create_windows(SdlContext* sdl)
{
  WINPR_ASSERT(sdl);
 
  auto settings = sdl->context()->settings;
  auto title = sdl_window_get_title(settings);
 
  ScopeGuard guard([&]() { sdl->windows_created.set(); });
 
  UINT32 windowCount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
 
  for (UINT32 x = 0; x < windowCount; x++)
  {
    auto id = sdl_monitor_id_for_index(sdl, x);
    if (id < 0)
      return FALSE;
    auto monitor = static_cast<rdpMonitor*>(
        freerdp_settings_get_pointer_array_writable(settings, FreeRDP_MonitorDefArray, x));
 
    Uint32 w = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
    Uint32 h = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
    if (!(freerdp_settings_get_bool(settings, FreeRDP_UseMultimon) ||
          freerdp_settings_get_bool(settings, FreeRDP_Fullscreen)))
    {
      w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
      h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
    }
 
    Uint32 flags = SDL_WINDOW_SHOWN;
    auto startupX = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
    auto startupY = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
 
    if (monitor->attributes.desktopScaleFactor > 100)
    {
#if SDL_VERSION_ATLEAST(2, 0, 1)
      flags |= SDL_WINDOW_ALLOW_HIGHDPI;
#endif
    }
 
    if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) &&
        !freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
    {
      flags |= SDL_WINDOW_FULLSCREEN;
    }
 
    if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
    {
      flags |= SDL_WINDOW_BORDERLESS;
    }
 
    if (!freerdp_settings_get_bool(settings, FreeRDP_Decorations))
      flags |= SDL_WINDOW_BORDERLESS;
 
    SdlWindow window{ title,
                    static_cast<int>(startupX),
                    static_cast<int>(startupY),
                    static_cast<int>(w),
                    static_cast<int>(h),
                    flags };
 
    if (!window.window())
      return FALSE;
 
    if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
    {
      auto r = window.rect();
      window.setOffsetX(0 - r.x);
      window.setOffsetY(0 - r.y);
    }
 
    sdl->windows.insert({ window.id(), std::move(window) });
  }
 
  return TRUE;
}
 
static BOOL sdl_wait_create_windows(SdlContext* sdl)
{
  std::scoped_lock lock(sdl->critical);
  sdl->windows_created.clear();
  if (!sdl_push_user_event(SDL_USEREVENT_CREATE_WINDOWS, sdl))
    return FALSE;
 
  HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
 
  const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
  switch (rc)
  {
    case WAIT_OBJECT_0:
      return TRUE;
    default:
      return FALSE;
  }
}
 
static bool shall_abort(SdlContext* sdl)
{
  std::scoped_lock lock(sdl->critical);
  if (freerdp_shall_disconnect_context(sdl->context()))
  {
    if (sdl->rdp_thread_running)
      return false;
    if (!sdl->connection_dialog)
      return true;
    return !sdl->connection_dialog->running();
  }
  return false;
}
 
static int sdl_run(SdlContext* sdl)
{
  int rc = -1;
  WINPR_ASSERT(sdl);
 
  HANDLE handles[] = { sdl->initialize.handle(), freerdp_abort_event(sdl->context()) };
  const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
  switch (status)
  {
    case WAIT_OBJECT_0:
      break;
    default:
      return 0;
  }
 
  SDL_Init(SDL_INIT_VIDEO);
  TTF_Init();
#if SDL_VERSION_ATLEAST(2, 0, 16)
  SDL_SetHint(SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED, "0");
#endif
#if SDL_VERSION_ATLEAST(2, 0, 8)
  SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0");
#endif
 
  if (!freerdp_add_signal_cleanup_handler(sdl->context(), sdl_term_handler))
    return -1;
 
  sdl->initialized.set();
 
  while (!shall_abort(sdl))
  {
    SDL_Event windowEvent = {};
    while (!shall_abort(sdl) && SDL_WaitEventTimeout(nullptr, 1000))
    {
      /* Only poll standard SDL events and SDL_USEREVENTS meant to create dialogs.
       * do not process the dialog return value events here.
       */
      const int prc = SDL_PeepEvents(&windowEvent, 1, SDL_GETEVENT, SDL_FIRSTEVENT,
                                     SDL_USEREVENT_RETRY_DIALOG);
      if (prc < 0)
      {
        if (sdl_log_error(prc, sdl->log, "SDL_PeepEvents"))
          continue;
      }
 
      WLog_Print(sdl->log, WLOG_TRACE, "got event %s [0x%08" PRIx32 "]",
                 sdl_event_type_str(windowEvent.type), windowEvent.type);
      std::scoped_lock lock(sdl->critical);
      /* The session might have been disconnected while we were waiting for a new SDL event.
       * In that case ignore the SDL event and terminate. */
      if (freerdp_shall_disconnect_context(sdl->context()))
        continue;
 
      if (sdl->connection_dialog)
      {
        if (sdl->connection_dialog->handle(windowEvent))
        {
          continue;
        }
      }
 
      switch (windowEvent.type)
      {
        case SDL_QUIT:
          freerdp_abort_connect_context(sdl->context());
          break;
        case SDL_KEYDOWN:
        case SDL_KEYUP:
        {
          const SDL_KeyboardEvent* ev = &windowEvent.key;
          sdl->input.keyboard_handle_event(ev);
        }
        break;
        case SDL_KEYMAPCHANGED:
        {
        }
        break; // TODO: Switch keyboard layout
        case SDL_MOUSEMOTION:
        {
          const SDL_MouseMotionEvent* ev = &windowEvent.motion;
          sdl_handle_mouse_motion(sdl, ev);
        }
        break;
        case SDL_MOUSEBUTTONDOWN:
        case SDL_MOUSEBUTTONUP:
        {
          const SDL_MouseButtonEvent* ev = &windowEvent.button;
          sdl_handle_mouse_button(sdl, ev);
        }
        break;
        case SDL_MOUSEWHEEL:
        {
          const SDL_MouseWheelEvent* ev = &windowEvent.wheel;
          sdl_handle_mouse_wheel(sdl, ev);
        }
        break;
        case SDL_FINGERDOWN:
        {
          const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
          sdl_handle_touch_down(sdl, ev);
        }
        break;
        case SDL_FINGERUP:
        {
          const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
          sdl_handle_touch_up(sdl, ev);
        }
        break;
        case SDL_FINGERMOTION:
        {
          const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
          sdl_handle_touch_motion(sdl, ev);
        }
        break;
#if SDL_VERSION_ATLEAST(2, 0, 10)
        case SDL_DISPLAYEVENT:
        {
          const SDL_DisplayEvent* ev = &windowEvent.display;
          sdl->disp.handle_display_event(ev);
        }
        break;
#endif
        case SDL_WINDOWEVENT:
        {
          const SDL_WindowEvent* ev = &windowEvent.window;
          auto window = sdl->windows.find(ev->windowID);
          if (window != sdl->windows.end())
            sdl->disp.handle_window_event(ev);
          switch (ev->event)
          {
            case SDL_WINDOWEVENT_RESIZED:
            case SDL_WINDOWEVENT_SIZE_CHANGED:
            {
              if (window != sdl->windows.end())
              {
                window->second.fill();
                window->second.updateSurface();
              }
            }
            break;
            case SDL_WINDOWEVENT_MOVED:
            {
              if (window != sdl->windows.end())
              {
                auto r = window->second.rect();
                auto id = window->second.id();
                WLog_DBG(SDL_TAG, "%u: %dx%d-%dx%d", id, r.x, r.y, r.w, r.h);
              }
            }
            break;
            default:
              break;
          }
        }
        break;
 
        case SDL_RENDER_TARGETS_RESET:
          sdl_redraw(sdl);
          break;
        case SDL_RENDER_DEVICE_RESET:
          sdl_redraw(sdl);
          break;
        case SDL_APP_WILLENTERFOREGROUND:
          sdl_redraw(sdl);
          break;
        case SDL_USEREVENT_CERT_DIALOG:
        {
          auto title = static_cast<const char*>(windowEvent.user.data1);
          auto msg = static_cast<const char*>(windowEvent.user.data2);
          sdl_cert_dialog_show(title, msg);
        }
        break;
        case SDL_USEREVENT_SHOW_DIALOG:
        {
          auto title = static_cast<const char*>(windowEvent.user.data1);
          auto msg = static_cast<const char*>(windowEvent.user.data2);
          sdl_message_dialog_show(title, msg, windowEvent.user.code);
        }
        break;
        case SDL_USEREVENT_SCARD_DIALOG:
        {
          auto title = static_cast<const char*>(windowEvent.user.data1);
          auto msg = static_cast<const char**>(windowEvent.user.data2);
          sdl_scard_dialog_show(title, windowEvent.user.code, msg);
        }
        break;
        case SDL_USEREVENT_AUTH_DIALOG:
          sdl_auth_dialog_show(
              reinterpret_cast<const SDL_UserAuthArg*>(windowEvent.padding));
          break;
        case SDL_USEREVENT_UPDATE:
        {
          auto context = static_cast<rdpContext*>(windowEvent.user.data1);
          sdl_end_paint_process(context);
        }
        break;
        case SDL_USEREVENT_CREATE_WINDOWS:
        {
          auto ctx = static_cast<SdlContext*>(windowEvent.user.data1);
          sdl_create_windows(ctx);
        }
        break;
        case SDL_USEREVENT_WINDOW_RESIZEABLE:
        {
          auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
          const SDL_bool use = windowEvent.user.code != 0 ? SDL_TRUE : SDL_FALSE;
          if (window)
            window->resizeable(use);
        }
        break;
        case SDL_USEREVENT_WINDOW_FULLSCREEN:
        {
          auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
          const SDL_bool enter = windowEvent.user.code != 0 ? SDL_TRUE : SDL_FALSE;
          if (window)
            window->fullscreen(enter);
        }
        break;
        case SDL_USEREVENT_WINDOW_MINIMIZE:
        {
          for (auto& window : sdl->windows)
          {
            window.second.minimize();
          }
        }
        break;
        case SDL_USEREVENT_POINTER_NULL:
          SDL_ShowCursor(SDL_DISABLE);
          break;
        case SDL_USEREVENT_POINTER_DEFAULT:
        {
          SDL_Cursor* def = SDL_GetDefaultCursor();
          SDL_SetCursor(def);
          SDL_ShowCursor(SDL_ENABLE);
        }
        break;
        case SDL_USEREVENT_POINTER_POSITION:
        {
          const auto x =
              static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data1));
          const auto y =
              static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data2));
 
          SDL_Window* window = SDL_GetMouseFocus();
          if (window)
          {
            const Uint32 id = SDL_GetWindowID(window);
 
            INT32 sx = x;
            INT32 sy = y;
            if (sdl_scale_coordinates(sdl, id, &sx, &sy, FALSE, FALSE))
              SDL_WarpMouseInWindow(window, sx, sy);
          }
        }
        break;
        case SDL_USEREVENT_POINTER_SET:
          sdl_Pointer_Set_Process(&windowEvent.user);
          break;
        case SDL_USEREVENT_QUIT:
        default:
          break;
      }
    }
  }
 
  rc = 1;
 
  sdl_cleanup_sdl(sdl);
  return rc;
}
 
/* Called after a RDP connection was successfully established.
 * Settings might have changed during negotiation of client / server feature
 * support.
 *
 * Set up local framebuffers and paing callbacks.
 * If required, register pointer callbacks to change the local mouse cursor
 * when hovering over the RDP window
 */
static BOOL sdl_post_connect(freerdp* instance)
{
  WINPR_ASSERT(instance);
 
  auto context = instance->context;
  WINPR_ASSERT(context);
 
  auto sdl = get_context(context);
 
  // Retry was successful, discard dialog
  sdl_hide_connection_dialog(sdl);
 
  if (freerdp_settings_get_bool(context->settings, FreeRDP_AuthenticationOnly))
  {
    /* Check +auth-only has a username and password. */
    if (!freerdp_settings_get_string(context->settings, FreeRDP_Password))
    {
      WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
      return FALSE;
    }
 
    WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect to X.");
    return TRUE;
  }
 
  if (!sdl_wait_create_windows(sdl))
    return FALSE;
 
  sdl->sdl_pixel_format = SDL_PIXELFORMAT_BGRA32;
  if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
    return FALSE;
 
  if (!sdl_create_primary(sdl))
    return FALSE;
 
  if (!sdl_register_pointer(instance->context->graphics))
    return FALSE;
 
  WINPR_ASSERT(context->update);
 
  context->update->BeginPaint = sdl_begin_paint;
  context->update->EndPaint = sdl_end_paint;
  context->update->PlaySound = sdl_play_sound;
  context->update->DesktopResize = sdl_desktop_resize;
  context->update->SetKeyboardIndicators = sdlInput::keyboard_set_indicators;
  context->update->SetKeyboardImeStatus = sdlInput::keyboard_set_ime_status;
 
  sdl->update_resizeable(FALSE);
  sdl->update_fullscreen(freerdp_settings_get_bool(context->settings, FreeRDP_Fullscreen) ||
                         freerdp_settings_get_bool(context->settings, FreeRDP_UseMultimon));
  return TRUE;
}
 
/* This function is called whether a session ends by failure or success.
 * Clean up everything allocated by pre_connect and post_connect.
 */
static void sdl_post_disconnect(freerdp* instance)
{
  if (!instance)
    return;
 
  if (!instance->context)
    return;
 
  PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
                                     sdl_OnChannelConnectedEventHandler);
  PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
                                        sdl_OnChannelDisconnectedEventHandler);
  PubSub_UnsubscribeUserNotification(instance->context->pubSub,
                                     sdl_OnUserNotificationEventHandler);
 
  gdi_free(instance);
}
 
static void sdl_post_final_disconnect(freerdp* instance)
{
  if (!instance)
    return;
 
  if (!instance->context)
    return;
}
 
static void sdl_client_cleanup(SdlContext* sdl, int exit_code, const std::string& error_msg)
{
  WINPR_ASSERT(sdl);
 
  rdpContext* context = sdl->context();
  WINPR_ASSERT(context);
 
  rdpSettings* settings = context->settings;
  WINPR_ASSERT(settings);
 
  sdl->rdp_thread_running = false;
  bool showError = false;
  if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
    WLog_Print(sdl->log, WLOG_INFO, "Authentication only, exit status %s [%" PRId32 "]",
               sdl_map_to_code_tag(exit_code), exit_code);
  else
  {
    switch (exit_code)
    {
      case SDL_EXIT_SUCCESS:
      case SDL_EXIT_DISCONNECT:
      case SDL_EXIT_LOGOFF:
      case SDL_EXIT_DISCONNECT_BY_USER:
      case SDL_EXIT_CONNECT_CANCELLED:
        break;
      default:
      {
        std::scoped_lock lock(sdl->critical);
        if (sdl->connection_dialog && !error_msg.empty())
        {
          sdl->connection_dialog->showError(error_msg.c_str());
          showError = true;
        }
      }
      break;
    }
  }
 
  if (!showError)
    sdl_hide_connection_dialog(sdl);
 
  sdl->exit_code = exit_code;
  sdl_push_user_event(SDL_USEREVENT_QUIT);
#if SDL_VERSION_ATLEAST(2, 0, 16)
  SDL_TLSCleanup();
#endif
}
 
static int sdl_client_thread_connect(SdlContext* sdl, std::string& error_msg)
{
  WINPR_ASSERT(sdl);
 
  auto instance = sdl->context()->instance;
  WINPR_ASSERT(instance);
 
  sdl->rdp_thread_running = true;
  BOOL rc = freerdp_connect(instance);
 
  rdpContext* context = sdl->context();
  WINPR_ASSERT(context);
 
  rdpSettings* settings = context->settings;
  WINPR_ASSERT(settings);
 
  int exit_code = SDL_EXIT_SUCCESS;
  if (!rc)
  {
    UINT32 error = freerdp_get_last_error(context);
    exit_code = sdl_map_error_to_exit_code(error);
  }
 
  if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
  {
    DWORD code = freerdp_get_last_error(context);
    freerdp_abort_connect_context(context);
    WLog_Print(sdl->log, WLOG_ERROR, "Authentication only, %s [0x%08" PRIx32 "] %s",
               freerdp_get_last_error_name(code), code, freerdp_get_last_error_string(code));
    return exit_code;
  }
 
  if (!rc)
  {
    DWORD code = freerdp_error_info(instance);
    if (exit_code == SDL_EXIT_SUCCESS)
    {
      char* msg = nullptr;
      size_t len = 0;
      exit_code = error_info_to_error(instance, &code, &msg, &len);
      if (msg)
        error_msg = msg;
      free(msg);
    }
 
    auto last = freerdp_get_last_error(context);
    if (error_msg.empty())
    {
      char* msg = nullptr;
      size_t len = 0;
      winpr_asprintf(&msg, &len, "%s [0x%08" PRIx32 "]\n%s",
                     freerdp_get_last_error_name(last), last,
                     freerdp_get_last_error_string(last));
      if (msg)
        error_msg = msg;
      free(msg);
    }
 
    if (exit_code == SDL_EXIT_SUCCESS)
    {
      if (last == FREERDP_ERROR_AUTHENTICATION_FAILED)
        exit_code = SDL_EXIT_AUTH_FAILURE;
      else if (code == ERRINFO_SUCCESS)
        exit_code = SDL_EXIT_CONN_FAILED;
    }
 
    sdl_hide_connection_dialog(sdl);
  }
  return exit_code;
}
 
static int sdl_client_thread_run(SdlContext* sdl, std::string& error_msg)
{
  WINPR_ASSERT(sdl);
 
  auto context = sdl->context();
  WINPR_ASSERT(context);
 
  auto instance = context->instance;
  WINPR_ASSERT(instance);
 
  int exit_code = SDL_EXIT_SUCCESS;
  while (!freerdp_shall_disconnect_context(context))
  {
    HANDLE handles[MAXIMUM_WAIT_OBJECTS] = {};
    /*
     * win8 and server 2k12 seem to have some timing issue/race condition
     * when a initial sync request is send to sync the keyboard indicators
     * sending the sync event twice fixed this problem
     */
    if (freerdp_focus_required(instance))
    {
      auto ctx = get_context(context);
      WINPR_ASSERT(ctx);
      if (!ctx->input.keyboard_focus_in())
        break;
      if (!ctx->input.keyboard_focus_in())
        break;
    }
 
    const DWORD nCount = freerdp_get_event_handles(context, handles, ARRAYSIZE(handles));
 
    if (nCount == 0)
    {
      WLog_Print(sdl->log, WLOG_ERROR, "freerdp_get_event_handles failed");
      break;
    }
 
    const DWORD status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
 
    if (status == WAIT_FAILED)
      break;
 
    if (!freerdp_check_event_handles(context))
    {
      if (client_auto_reconnect(instance))
      {
        // Retry was successful, discard dialog
        sdl_hide_connection_dialog(sdl);
        continue;
      }
      else
      {
        /*
         * Indicate an unsuccessful connection attempt if reconnect
         * did not succeed and no other error was specified.
         */
        if (freerdp_error_info(instance) == 0)
          exit_code = SDL_EXIT_CONN_FAILED;
      }
 
      if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
        WLog_Print(sdl->log, WLOG_ERROR, "WaitForMultipleObjects failed with %" PRIu32 "",
                   status);
      if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
        WLog_Print(sdl->log, WLOG_ERROR, "Failed to check FreeRDP event handles");
      break;
    }
  }
 
  if (exit_code == SDL_EXIT_SUCCESS)
  {
    DWORD code = 0;
    {
      char* msg = nullptr;
      size_t len = 0;
      exit_code = error_info_to_error(instance, &code, &msg, &len);
      if (msg)
        error_msg = msg;
      free(msg);
    }
 
    if ((code == ERRINFO_LOGOFF_BY_USER) &&
        (freerdp_get_disconnect_ultimatum(context) == Disconnect_Ultimatum_user_requested))
    {
      const char* msg = "Error info says user did not initiate but disconnect ultimatum says "
                        "they did; treat this as a user logoff";
      char* emsg = nullptr;
      size_t len = 0;
      winpr_asprintf(&emsg, &len, "%s", msg);
      if (emsg)
        error_msg = emsg;
      free(emsg);
      /* This situation might be limited to Windows XP. */
      WLog_Print(sdl->log, WLOG_INFO, "%s", msg);
      exit_code = SDL_EXIT_LOGOFF;
    }
  }
 
  freerdp_disconnect(instance);
  return exit_code;
}
 
/* RDP main loop.
 * Connects RDP, loops while running and handles event and dispatch, cleans up
 * after the connection ends. */
static DWORD WINAPI sdl_client_thread_proc(SdlContext* sdl)
{
  WINPR_ASSERT(sdl);
 
  std::string error_msg;
  int exit_code = sdl_client_thread_connect(sdl, error_msg);
  if (exit_code == SDL_EXIT_SUCCESS)
    exit_code = sdl_client_thread_run(sdl, error_msg);
  sdl_client_cleanup(sdl, exit_code, error_msg);
 
  return static_cast<DWORD>(exit_code);
}
 
/* Optional global initializer.
 * Here we just register a signal handler to print out stack traces
 * if available. */
static BOOL sdl_client_global_init()
{
#if defined(_WIN32)
  WSADATA wsaData = {};
  const DWORD wVersionRequested = MAKEWORD(1, 1);
  const int rc = WSAStartup(wVersionRequested, &wsaData);
  if (rc != 0)
  {
    WLog_ERR(SDL_TAG, "WSAStartup failed with %s [%d]", gai_strerrorA(rc), rc);
    return FALSE;
  }
#endif
 
  return freerdp_handle_signals() == 0;
}
 
/* Optional global tear down */
static void sdl_client_global_uninit()
{
#if defined(_WIN32)
  WSACleanup();
#endif
}
 
static BOOL sdl_client_new(freerdp* instance, rdpContext* context)
{
  auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
 
  if (!instance || !context)
    return FALSE;
 
  sdl->sdl = new SdlContext(context);
  if (!sdl->sdl)
    return FALSE;
 
  instance->PreConnect = sdl_pre_connect;
  instance->PostConnect = sdl_post_connect;
  instance->PostDisconnect = sdl_post_disconnect;
  instance->PostFinalDisconnect = sdl_post_final_disconnect;
  instance->AuthenticateEx = sdl_authenticate_ex;
  instance->VerifyCertificateEx = sdl_verify_certificate_ex;
  instance->VerifyChangedCertificateEx = sdl_verify_changed_certificate_ex;
  instance->LogonErrorInfo = sdl_logon_error_info;
  instance->PresentGatewayMessage = sdl_present_gateway_message;
  instance->ChooseSmartcard = sdl_choose_smartcard;
  instance->RetryDialog = sdl_retry_dialog;
  instance->GetAccessToken = client_failsafe_get_access_token;
  /* TODO: Client display set up */
 
  return TRUE;
}
 
static void sdl_client_free([[maybe_unused]] freerdp* instance, rdpContext* context)
{
  auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
 
  if (!context)
    return;
 
  delete sdl->sdl;
}
 
static int sdl_client_start(rdpContext* context)
{
  auto sdl = get_context(context);
  WINPR_ASSERT(sdl);
 
  sdl->thread = std::thread(sdl_client_thread_proc, sdl);
  return 0;
}
 
static int sdl_client_stop(rdpContext* context)
{
  auto sdl = get_context(context);
  WINPR_ASSERT(sdl);
 
  /* We do not want to use freerdp_abort_connect_context here.
   * It would change the exit code and we do not want that. */
  HANDLE event = freerdp_abort_event(context);
  if (!SetEvent(event))
    return -1;
 
  sdl->thread.join();
  return 0;
}
 
static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
{
  WINPR_ASSERT(pEntryPoints);
 
  ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
  pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
  pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
  pEntryPoints->GlobalInit = sdl_client_global_init;
  pEntryPoints->GlobalUninit = sdl_client_global_uninit;
  pEntryPoints->ContextSize = sizeof(sdl_rdp_context);
  pEntryPoints->ClientNew = sdl_client_new;
  pEntryPoints->ClientFree = sdl_client_free;
  pEntryPoints->ClientStart = sdl_client_start;
  pEntryPoints->ClientStop = sdl_client_stop;
  return 0;
}
 
static void context_free(sdl_rdp_context* sdl)
{
  if (sdl)
    freerdp_client_context_free(&sdl->common.context);
}
 
static const char* category2str(int category)
{
  switch (category)
  {
    case SDL_LOG_CATEGORY_APPLICATION:
      return "SDL_LOG_CATEGORY_APPLICATION";
    case SDL_LOG_CATEGORY_ERROR:
      return "SDL_LOG_CATEGORY_ERROR";
    case SDL_LOG_CATEGORY_ASSERT:
      return "SDL_LOG_CATEGORY_ASSERT";
    case SDL_LOG_CATEGORY_SYSTEM:
      return "SDL_LOG_CATEGORY_SYSTEM";
    case SDL_LOG_CATEGORY_AUDIO:
      return "SDL_LOG_CATEGORY_AUDIO";
    case SDL_LOG_CATEGORY_VIDEO:
      return "SDL_LOG_CATEGORY_VIDEO";
    case SDL_LOG_CATEGORY_RENDER:
      return "SDL_LOG_CATEGORY_RENDER";
    case SDL_LOG_CATEGORY_INPUT:
      return "SDL_LOG_CATEGORY_INPUT";
    case SDL_LOG_CATEGORY_TEST:
      return "SDL_LOG_CATEGORY_TEST";
    case SDL_LOG_CATEGORY_RESERVED1:
      return "SDL_LOG_CATEGORY_RESERVED1";
    case SDL_LOG_CATEGORY_RESERVED2:
      return "SDL_LOG_CATEGORY_RESERVED2";
    case SDL_LOG_CATEGORY_RESERVED3:
      return "SDL_LOG_CATEGORY_RESERVED3";
    case SDL_LOG_CATEGORY_RESERVED4:
      return "SDL_LOG_CATEGORY_RESERVED4";
    case SDL_LOG_CATEGORY_RESERVED5:
      return "SDL_LOG_CATEGORY_RESERVED5";
    case SDL_LOG_CATEGORY_RESERVED6:
      return "SDL_LOG_CATEGORY_RESERVED6";
    case SDL_LOG_CATEGORY_RESERVED7:
      return "SDL_LOG_CATEGORY_RESERVED7";
    case SDL_LOG_CATEGORY_RESERVED8:
      return "SDL_LOG_CATEGORY_RESERVED8";
    case SDL_LOG_CATEGORY_RESERVED9:
      return "SDL_LOG_CATEGORY_RESERVED9";
    case SDL_LOG_CATEGORY_RESERVED10:
      return "SDL_LOG_CATEGORY_RESERVED10";
    case SDL_LOG_CATEGORY_CUSTOM:
    default:
      return "SDL_LOG_CATEGORY_CUSTOM";
  }
}
 
static SDL_LogPriority wloglevel2dl(DWORD level)
{
  switch (level)
  {
    case WLOG_TRACE:
      return SDL_LOG_PRIORITY_VERBOSE;
    case WLOG_DEBUG:
      return SDL_LOG_PRIORITY_DEBUG;
    case WLOG_INFO:
      return SDL_LOG_PRIORITY_INFO;
    case WLOG_WARN:
      return SDL_LOG_PRIORITY_WARN;
    case WLOG_ERROR:
      return SDL_LOG_PRIORITY_ERROR;
    case WLOG_FATAL:
      return SDL_LOG_PRIORITY_CRITICAL;
    case WLOG_OFF:
    default:
      return SDL_LOG_PRIORITY_VERBOSE;
  }
}
 
static DWORD sdlpriority2wlog(SDL_LogPriority priority)
{
  DWORD level = WLOG_OFF;
  switch (priority)
  {
    case SDL_LOG_PRIORITY_VERBOSE:
      level = WLOG_TRACE;
      break;
    case SDL_LOG_PRIORITY_DEBUG:
      level = WLOG_DEBUG;
      break;
    case SDL_LOG_PRIORITY_INFO:
      level = WLOG_INFO;
      break;
    case SDL_LOG_PRIORITY_WARN:
      level = WLOG_WARN;
      break;
    case SDL_LOG_PRIORITY_ERROR:
      level = WLOG_ERROR;
      break;
    case SDL_LOG_PRIORITY_CRITICAL:
      level = WLOG_FATAL;
      break;
    default:
      break;
  }
 
  return level;
}
 
static void SDLCALL winpr_LogOutputFunction(void* userdata, int category, SDL_LogPriority priority,
                                            const char* message)
{
  auto sdl = static_cast<SdlContext*>(userdata);
  WINPR_ASSERT(sdl);
 
  const DWORD level = sdlpriority2wlog(priority);
  auto log = sdl->log;
  if (!WLog_IsLevelActive(log, level))
    return;
 
  WLog_PrintTextMessage(log, level, __LINE__, __FILE__, __func__, "[%s] %s",
                        category2str(category), message);
}
 
int main(int argc, char* argv[])
{
#if defined(_WIN32)
  sdl::win32::release_transient_console();
#endif
 
  int rc = -1;
  int status = 0;
  RDP_CLIENT_ENTRY_POINTS clientEntryPoints = {};
 
  freerdp_client_warn_experimental(argc, argv);
  freerdp_client_warn_deprecated(argc, argv);
  WLog_WARN(SDL_TAG,
            "SDL2 client does not support clipboard! Only SDL3 client has (partial) support");
 
  RdpClientEntry(&clientEntryPoints);
  std::unique_ptr<sdl_rdp_context, void (*)(sdl_rdp_context*)> sdl_rdp(
      reinterpret_cast<sdl_rdp_context*>(freerdp_client_context_new(&clientEntryPoints)),
      context_free);
 
  if (!sdl_rdp)
    return -1;
  auto sdl = sdl_rdp->sdl;
 
  auto settings = sdl->context()->settings;
  WINPR_ASSERT(settings);
 
  status = freerdp_client_settings_parse_command_line(settings, argc, argv, FALSE);
  if (status)
  {
    rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
    if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
      sdl_list_monitors(sdl);
    else
    {
      switch (status)
      {
        case COMMAND_LINE_STATUS_PRINT:
        case COMMAND_LINE_STATUS_PRINT_VERSION:
        case COMMAND_LINE_STATUS_PRINT_BUILDCONFIG:
          break;
        case COMMAND_LINE_STATUS_PRINT_HELP:
        default:
          SdlPref::print_config_file_help(2);
          break;
      }
    }
    return rc;
  }
 
  SDL_LogSetOutputFunction(winpr_LogOutputFunction, sdl);
  auto level = WLog_GetLogLevel(sdl->log);
  SDL_LogSetAllPriority(wloglevel2dl(level));
 
  auto context = sdl->context();
  WINPR_ASSERT(context);
 
  if (!stream_dump_register_handlers(context, CONNECTION_STATE_MCS_CREATE_REQUEST, FALSE))
    return -1;
 
  if (freerdp_client_start(context) != 0)
    return -1;
 
  rc = sdl_run(sdl);
 
  if (freerdp_client_stop(context) != 0)
    return -1;
 
  if (sdl->exit_code != 0)
    rc = sdl->exit_code;
 
  return rc;
}
 
BOOL SdlContext::update_fullscreen(BOOL enter)
{
  std::scoped_lock lock(critical);
  for (const auto& window : windows)
  {
    if (!sdl_push_user_event(SDL_USEREVENT_WINDOW_FULLSCREEN, &window.second, enter))
      return FALSE;
  }
  fullscreen = enter;
  return TRUE;
}
 
BOOL SdlContext::update_minimize()
{
  std::scoped_lock lock(critical);
  return sdl_push_user_event(SDL_USEREVENT_WINDOW_MINIMIZE);
}
 
BOOL SdlContext::update_resizeable(BOOL enable)
{
  std::scoped_lock lock(critical);
 
  const auto settings = context()->settings;
  const BOOL dyn = freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate);
  const BOOL smart = freerdp_settings_get_bool(settings, FreeRDP_SmartSizing);
  BOOL use = (dyn && enable) || smart;
 
  for (const auto& window : windows)
  {
    if (!sdl_push_user_event(SDL_USEREVENT_WINDOW_RESIZEABLE, &window.second, use))
      return FALSE;
  }
  resizeable = use;
 
  return TRUE;
}
 
SdlContext::SdlContext(rdpContext* context)
    : _context(context), log(WLog_Get(SDL_TAG)), update_complete(true), disp(this), input(this),
      primary(nullptr, SDL_FreeSurface), primary_format(nullptr, SDL_FreeFormat),
      rdp_thread_running(false)
{
  WINPR_ASSERT(context);
  grab_kbd_enabled = freerdp_settings_get_bool(context->settings, FreeRDP_GrabKeyboard);
}
 
rdpContext* SdlContext::context() const
{
  return _context;
}
 
rdpClientContext* SdlContext::common() const
{
  return reinterpret_cast<rdpClientContext*>(_context);
}
 
std::shared_ptr<SdlAadAuthHelper>& SdlContext::getAadAuthHelper()
{
  return _aadAuthHelper;
}