/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * RDP Settings

 *

 * Copyright 2009-2011 Jay Sorg

 * Copyright 2023 Armin Novak <anovak@thincast.com>

 * Copyright 2023 Thincast Technologies GmbH

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <freerdp/config.h>

#include "settings.h"

#include <freerdp/crypto/certificate.h>

#include <ctype.h>

#include <winpr/crt.h>

#include <winpr/file.h>

#include <winpr/path.h>

#include <winpr/sysinfo.h>

#include <winpr/registry.h>

#include <winpr/wtsapi.h>

#include <freerdp/settings.h>

#include <freerdp/build-config.h>

#include "../crypto/certificate.h"

#include "../crypto/privatekey.h"

#include "capabilities.h"

#define TAG FREERDP_TAG("settings")

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4244)

#endif

static const char client_dll[] = "C:\\Windows\\System32\\mstscax.dll";

#define SERVER_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Server"

#define CLIENT_KEY "Software\\" FREERDP_VENDOR_STRING "\\" FREERDP_PRODUCT_STRING "\\Client"

#define BITMAP_CACHE_KEY CLIENT_KEY "\\BitmapCacheV2"

#define GLYPH_CACHE_KEY CLIENT_KEY "\\GlyphCache"

#define POINTER_CACHE_KEY CLIENT_KEY "\\PointerCache"

struct bounds_t

{

  INT32 x;

  INT32 y;

  INT32 width;

  INT32 height;

};

static const char* bounds2str(const struct bounds_t* bounds, char* buffer, size_t len)

{

  WINPR_ASSERT(bounds);

  (void)_snprintf(buffer, len, "{%dx%d-%dx%d}", bounds->x, bounds->y, bounds->x + bounds->width,

                  bounds->y + bounds->height);

  return buffer;

}

static struct bounds_t union_rect(const struct bounds_t* a, const struct bounds_t* b)

{

  WINPR_ASSERT(a);

  WINPR_ASSERT(b);

  struct bounds_t u = *a;

  if (b->x < u.x)

    u.x = b->x;

  if (b->y < u.y)

    u.y = b->y;

  const INT32 rightA = a->x + a->width;

  const INT32 rightB = b->x + b->width;

  const INT32 right = MAX(rightA, rightB);

  u.width = right - u.x;

  const INT32 bottomA = a->y + a->height;

  const INT32 bottomB = b->y + b->height;

  const INT32 bottom = MAX(bottomA, bottomB);

  u.height = bottom - u.y;

  return u;

}

static BOOL intersect_rects(const struct bounds_t* r1, const struct bounds_t* r2)

{

  WINPR_ASSERT(r1);

  WINPR_ASSERT(r2);

  const INT32 left = MAX(r1->x, r2->x);

  const INT32 top = MAX(r1->y, r2->y);

  const INT32 right = MIN(r1->x + r1->width, r2->x + r2->width);

  const INT32 bottom = MIN(r1->y + r1->height, r2->y + r2->height);

  return (left < right) && (top < bottom);

}

static BOOL align_rects(const struct bounds_t* r1, const struct bounds_t* r2)

{

  WINPR_ASSERT(r1);

  WINPR_ASSERT(r2);

  const INT32 left = MAX(r1->x, r2->x);

  const INT32 top = MAX(r1->y, r2->y);

  const INT32 right = MIN(r1->x + r1->width, r2->x + r2->width);

  const INT32 bottom = MIN(r1->y + r1->height, r2->y + r2->height);

  return (left == right) || (top == bottom);

}

static BOOL settings_reg_query_dword_val(HKEY hKey, const TCHAR* sub, DWORD* value)

{

  DWORD dwType = 0;

  DWORD dwSize = 0;

  dwSize = sizeof(DWORD);

  if (RegQueryValueEx(hKey, sub, NULL, &dwType, (BYTE*)value, &dwSize) != ERROR_SUCCESS)

    return FALSE;

  if (dwType != REG_DWORD)

    return FALSE;

  return TRUE;

}

static BOOL settings_reg_query_word_val(HKEY hKey, const TCHAR* sub, UINT16* value)

{

  DWORD dwValue = 0;

  if (!settings_reg_query_dword_val(hKey, sub, &dwValue))

    return FALSE;

  if (dwValue > UINT16_MAX)

    return FALSE;

  *value = (UINT16)dwValue;

  return TRUE;

}

static BOOL settings_reg_query_bool_val(HKEY hKey, const TCHAR* sub, BOOL* value)

{

  DWORD dwValue = 0;

  if (!settings_reg_query_dword_val(hKey, sub, &dwValue))

    return FALSE;

  *value = dwValue != 0;

  return TRUE;

}

static BOOL settings_reg_query_dword(rdpSettings* settings, FreeRDP_Settings_Keys_UInt32 id,

                                     HKEY hKey, const TCHAR* sub)

{

  DWORD dwValue = 0;

  if (!settings_reg_query_dword_val(hKey, sub, &dwValue))

    return FALSE;

  return freerdp_settings_set_uint32(settings, id, dwValue);

}

static BOOL settings_reg_query_bool(rdpSettings* settings, FreeRDP_Settings_Keys_Bool id, HKEY hKey,

                                    const TCHAR* sub)

{

  DWORD dwValue = 0;

  if (!settings_reg_query_dword_val(hKey, sub, &dwValue))

    return FALSE;

  return freerdp_settings_set_bool(settings, id, dwValue != 0 ? TRUE : FALSE);

}

static void settings_client_load_hkey_local_machine(rdpSettings* settings)

{

  HKEY hKey = NULL;

  LONG status = 0;

  status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, CLIENT_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

  if (status == ERROR_SUCCESS)

  {

    settings_reg_query_dword(settings, FreeRDP_DesktopWidth, hKey, _T("DesktopWidth"));

    settings_reg_query_dword(settings, FreeRDP_DesktopHeight, hKey, _T("DesktopHeight"));

    settings_reg_query_bool(settings, FreeRDP_Fullscreen, hKey, _T("Fullscreen"));

    settings_reg_query_dword(settings, FreeRDP_ColorDepth, hKey, _T("ColorDepth"));

    settings_reg_query_dword(settings, FreeRDP_KeyboardType, hKey, _T("KeyboardType"));

    settings_reg_query_dword(settings, FreeRDP_KeyboardSubType, hKey, _T("KeyboardSubType"));

    settings_reg_query_dword(settings, FreeRDP_KeyboardFunctionKey, hKey,

                             _T("KeyboardFunctionKeys"));

    settings_reg_query_dword(settings, FreeRDP_KeyboardLayout, hKey, _T("KeyboardLayout"));

    settings_reg_query_bool(settings, FreeRDP_ExtSecurity, hKey, _T("ExtSecurity"));

    settings_reg_query_bool(settings, FreeRDP_NlaSecurity, hKey, _T("NlaSecurity"));

    settings_reg_query_bool(settings, FreeRDP_TlsSecurity, hKey, _T("TlsSecurity"));

    settings_reg_query_bool(settings, FreeRDP_RdpSecurity, hKey, _T("RdpSecurity"));

    settings_reg_query_bool(settings, FreeRDP_MstscCookieMode, hKey, _T("MstscCookieMode"));

    settings_reg_query_dword(settings, FreeRDP_CookieMaxLength, hKey, _T("CookieMaxLength"));

    settings_reg_query_bool(settings, FreeRDP_BitmapCacheEnabled, hKey, _T("BitmapCache"));

    settings_reg_query_dword(settings, FreeRDP_OffscreenSupportLevel, hKey,

                             _T("OffscreenBitmapCache"));

    settings_reg_query_dword(settings, FreeRDP_OffscreenCacheSize, hKey,

                             _T("OffscreenBitmapCacheSize"));

    settings_reg_query_dword(settings, FreeRDP_OffscreenCacheEntries, hKey,

                             _T("OffscreenBitmapCacheEntries"));

    RegCloseKey(hKey);

  }

  status =

      RegOpenKeyExA(HKEY_LOCAL_MACHINE, BITMAP_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

  if (status == ERROR_SUCCESS)

  {

    settings_reg_query_dword(settings, FreeRDP_BitmapCacheV2NumCells, hKey, _T("NumCells"));

    for (unsigned x = 0; x < 5; x++)

    {

      DWORD val = 0;

      TCHAR numentries[64] = { 0 };

      TCHAR persist[64] = { 0 };

      BITMAP_CACHE_V2_CELL_INFO cache = { 0 };

      (void)_sntprintf(numentries, ARRAYSIZE(numentries), _T("Cell%uNumEntries"), x);

      (void)_sntprintf(persist, ARRAYSIZE(persist), _T("Cell%uPersistent"), x);

      if (!settings_reg_query_dword_val(hKey, numentries, &val) ||

          !settings_reg_query_bool_val(hKey, persist, &cache.persistent) ||

          !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, x,

                                              &cache))

        WLog_WARN(TAG, "Failed to load registry keys to settings!");

      cache.numEntries = val;

    }

    settings_reg_query_bool(settings, FreeRDP_AllowCacheWaitingList, hKey,

                            _T("AllowCacheWaitingList"));

    RegCloseKey(hKey);

  }

  status =

      RegOpenKeyExA(HKEY_LOCAL_MACHINE, GLYPH_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

  if (status == ERROR_SUCCESS)

  {

    unsigned x = 0;

    UINT32 GlyphSupportLevel = 0;

    settings_reg_query_dword(settings, FreeRDP_GlyphSupportLevel, hKey, _T("SupportLevel"));

    for (; x < 10; x++)

    {

      GLYPH_CACHE_DEFINITION cache = { 0 };

      TCHAR numentries[64] = { 0 };

      TCHAR maxsize[64] = { 0 };

      (void)_sntprintf(numentries, ARRAYSIZE(numentries), _T("Cache%uNumEntries"), x);

      (void)_sntprintf(maxsize, ARRAYSIZE(maxsize), _T("Cache%uMaxCellSize"), x);

      settings_reg_query_word_val(hKey, numentries, &cache.cacheEntries);

      settings_reg_query_word_val(hKey, maxsize, &cache.cacheMaximumCellSize);

      if (!freerdp_settings_set_pointer_array(settings, FreeRDP_GlyphCache, x, &cache))

        WLog_WARN(TAG, "Failed to store GlyphCache %" PRIuz, x);

    }

    {

      GLYPH_CACHE_DEFINITION cache = { 0 };

      settings_reg_query_word_val(hKey, _T("FragCacheNumEntries"), &cache.cacheEntries);

      settings_reg_query_word_val(hKey, _T("FragCacheMaxCellSize"),

                                  &cache.cacheMaximumCellSize);

      if (!freerdp_settings_set_pointer_array(settings, FreeRDP_FragCache, x, &cache))

        WLog_WARN(TAG, "Failed to store FragCache");

    }

    RegCloseKey(hKey);

    if (!freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GlyphSupportLevel))

      WLog_WARN(TAG, "Failed to load registry keys to settings!");

  }

  status =

      RegOpenKeyExA(HKEY_LOCAL_MACHINE, POINTER_CACHE_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

  if (status == ERROR_SUCCESS)

  {

    settings_reg_query_dword(settings, FreeRDP_LargePointerFlag, hKey, _T("LargePointer"));

    settings_reg_query_dword(settings, FreeRDP_PointerCacheSize, hKey, _T("PointerCacheSize"));

    settings_reg_query_dword(settings, FreeRDP_ColorPointerCacheSize, hKey,

                             _T("ColorPointerCacheSize"));

    RegCloseKey(hKey);

  }

}

static void settings_server_load_hkey_local_machine(rdpSettings* settings)

{

  HKEY hKey = NULL;

  LONG status = 0;

  status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, SERVER_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);

  if (status != ERROR_SUCCESS)

    return;

  settings_reg_query_bool(settings, FreeRDP_ExtSecurity, hKey, _T("ExtSecurity"));

  settings_reg_query_bool(settings, FreeRDP_NlaSecurity, hKey, _T("NlaSecurity"));

  settings_reg_query_bool(settings, FreeRDP_TlsSecurity, hKey, _T("TlsSecurity"));

  settings_reg_query_dword(settings, FreeRDP_TlsSecLevel, hKey, _T("TlsSecLevel"));

  settings_reg_query_bool(settings, FreeRDP_RdpSecurity, hKey, _T("RdpSecurity"));

  RegCloseKey(hKey);

}

static void settings_load_hkey_local_machine(rdpSettings* settings)

{

  if (freerdp_settings_get_bool(settings, FreeRDP_ServerMode))

    settings_server_load_hkey_local_machine(settings);

  else

    settings_client_load_hkey_local_machine(settings);

}

static BOOL settings_init_computer_name(rdpSettings* settings)

{

  CHAR computerName[MAX_COMPUTERNAME_LENGTH + 1] = { 0 };

  DWORD nSize = ARRAYSIZE(computerName);

  if (!GetComputerNameExA(ComputerNameNetBIOS, computerName, &nSize))

    return FALSE;

  if (!freerdp_settings_set_string(settings, FreeRDP_ComputerName, computerName))

    return FALSE;

  return freerdp_settings_set_string(settings, FreeRDP_ClientHostname, computerName);

}

void freerdp_settings_print_warnings(const rdpSettings* settings)

{

  const UINT32 level = freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel);

  if (level != GLYPH_SUPPORT_NONE)

  {

    char buffer[32] = { 0 };

    WLog_WARN(TAG, "[experimental] enabled GlyphSupportLevel %s, expect visual artefacts!",

              freerdp_settings_glyph_level_string(level, buffer, sizeof(buffer)));

  }

}

static BOOL monitor_operlaps(const rdpSettings* settings, UINT32 orig, UINT32 start, UINT32 count,

                             const rdpMonitor* compare)

{

  const struct bounds_t rect1 = {

    .x = compare->x, .y = compare->y, .width = compare->width, .height = compare->height

  };

  for (UINT32 x = start; x < count; x++)

  {

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);

    const struct bounds_t rect2 = {

      .x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height

    };

    if (intersect_rects(&rect1, &rect2))

    {

      char buffer1[32] = { 0 };

      char buffer2[32] = { 0 };

      WLog_ERR(TAG, "Monitor %" PRIu32 " and %" PRIu32 " are overlapping:", orig, x);

      WLog_ERR(TAG, "%s overlapps with %s", bounds2str(&rect1, buffer1, sizeof(buffer1)),

               bounds2str(&rect2, buffer2, sizeof(buffer2)));

      WLog_ERR(

          TAG,

          "Mulitimonitor mode requested, but local layout has gaps or overlapping areas!");

      WLog_ERR(TAG,

               "Please reconfigure your local monitor setup so that there are no gaps or "

               "overlapping areas!");

      return TRUE;

    }

  }

  return FALSE;

}

static BOOL monitor_has_gaps(const rdpSettings* settings, UINT32 start, UINT32 count,

                             const rdpMonitor* compare, UINT32** graph)

{

  const struct bounds_t rect1 = {

    .x = compare->x, .y = compare->y, .width = compare->width, .height = compare->height

  };

  BOOL hasNeighbor = FALSE;

  for (UINT32 i = 0; i < count; i++)

  {

    if (i == start)

      continue;

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, i);

    const struct bounds_t rect2 = {

      .x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height

    };

    if (align_rects(&rect1, &rect2))

    {

      hasNeighbor = TRUE;

      graph[start][i] = 1;

      graph[i][start] = 1;

    }

  }

  if (!hasNeighbor)

  {

    WLog_ERR(TAG,

             "Monitor configuration has gaps! Monitor %" PRIu32 " does not have any neighbor",

             start);

  }

  return !hasNeighbor;

}

static void alloc_free(UINT32** ptr)

{

  free((void*)ptr);

}

WINPR_ATTR_MALLOC(alloc_free, 1)

static UINT32** alloc_array(size_t count)

{

  // NOLINTNEXTLINE(clang-analyzer-unix.MallocSizeof)

  BYTE* array = calloc(count * sizeof(uintptr_t), count * sizeof(UINT32));

  UINT32** dst = (UINT32**)array;

  UINT32* val = (UINT32*)(array + count * sizeof(uintptr_t));

  for (size_t x = 0; x < count; x++)

    dst[x] = &val[x];

  return dst;

}

/* Monitors in the array need to:

 *

 * 1. be connected to another monitor (edges touch but don't overlap or have gaps)

 * 2. all monitors need to be connected so there are no separate groups.

 *

 * So, what we do here is we use dijkstra algorithm to find a path from any start node

 * (lazy as we are we always use the first in the array) to each other node.

 */

static BOOL find_path_exists_with_dijkstra(UINT32** graph, size_t count, UINT32 start)

{

  if (count < 1)

    return FALSE;

  WINPR_ASSERT(start < count);

  UINT32** cost = alloc_array(count);

  WINPR_ASSERT(cost);

  UINT32* distance = calloc(count, sizeof(UINT32));

  WINPR_ASSERT(distance);

  UINT32* visited = calloc(count, sizeof(UINT32));

  WINPR_ASSERT(visited);

  UINT32* parent = calloc(count, sizeof(UINT32));

  WINPR_ASSERT(parent);

  for (size_t x = 0; x < count; x++)

  {

    for (size_t y = 0; y < count; y++)

    {

      if (graph[x][y] == 0)

        cost[x][y] = UINT32_MAX;

      else

        cost[x][y] = graph[x][y];

    }

  }

  for (UINT32 x = 0; x < count; x++)

  {

    distance[x] = cost[start][x];

    parent[x] = start;

    visited[x] = 0;

  }

  distance[start] = 0;

  visited[start] = 1;

  size_t pos = 1;

  UINT32 nextnode = UINT32_MAX;

  while (pos < count - 1)

  {

    UINT32 mindistance = UINT32_MAX;

    for (UINT32 x = 0; x < count; x++)

    {

      if ((distance[x] < mindistance) && !visited[x])

      {

        mindistance = distance[x];

        nextnode = x;

      }

    }

    visited[nextnode] = 1;

    for (size_t y = 0; y < count; y++)

    {

      if (!visited[y])

      {

        UINT32 dist = mindistance + cost[nextnode][y];

        if (dist < distance[y])

        {

          distance[y] = dist;

          parent[y] = nextnode;

        }

      }

    }

    pos++;

  }

  BOOL rc = TRUE;

  for (size_t x = 0; x < count; x++)

  {

    if (x != start)

    {

      if (distance[x] == UINT32_MAX)

      {

        WLog_ERR(TAG, "monitor %" PRIu32 " not connected with monitor %" PRIuz, start, x);

        rc = FALSE;

        break;

      }

    }

  }

  alloc_free(cost);

  free(distance);

  free(visited);

  free(parent);

  return rc;

}

static BOOL freerdp_settings_client_monitors_have_gaps(const rdpSettings* settings)

{

  BOOL rc = TRUE;

  const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);

  if (count <= 1)

    return FALSE;

  UINT32** graph = alloc_array(count);

  WINPR_ASSERT(graph);

  for (UINT32 x = 0; x < count; x++)

  {

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);

    if (monitor_has_gaps(settings, x, count, monitor, graph))

      goto fail;

  }

  rc = !find_path_exists_with_dijkstra(graph, count, 0);

fail:

  alloc_free(graph);

  return rc;

}

static void log_monitor(UINT32 idx, const rdpMonitor* monitor, wLog* log, DWORD level)

{

  WINPR_ASSERT(monitor);

  WLog_Print(log, level,

             "[%" PRIu32 "] [%s] {%dx%d-%dx%d} [%" PRIu32 "] {%" PRIu32 "x%" PRIu32

             ", orientation: %" PRIu32 ", desktopScale: %" PRIu32 ", deviceScale: %" PRIu32 "}",

             idx, monitor->is_primary ? "primary" : "       ", monitor->x, monitor->y,

             monitor->width, monitor->height, monitor->orig_screen,

             monitor->attributes.physicalWidth, monitor->attributes.physicalHeight,

             monitor->attributes.orientation, monitor->attributes.desktopScaleFactor,

             monitor->attributes.deviceScaleFactor);

}

static void log_monitor_configuration(const rdpSettings* settings, wLog* log, DWORD level)

{

  const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);

  WLog_Print(log, level, "[BEGIN] MonitorDefArray[%" PRIu32 "]", count);

  for (UINT32 x = 0; x < count; x++)

  {

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);

    log_monitor(x, monitor, log, level);

  }

  WLog_Print(log, level, "[END] MonitorDefArray[%" PRIu32 "]", count);

}

static BOOL freerdp_settings_client_monitors_overlap(const rdpSettings* settings)

{

  const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);

  for (UINT32 x = 0; x < count; x++)

  {

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);

    if (monitor_operlaps(settings, x, x + 1, count, monitor))

      return TRUE;

  }

  return FALSE;

}

/* See [MS-RDPBCGR] 2.2.1.3.6.1 for details on limits

 * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/c3964b39-3d54-4ae1-a84a-ceaed311e0f6

 */

static BOOL freerdp_settings_client_monitors_check_primary_and_origin(const rdpSettings* settings)

{

  const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);

  BOOL havePrimary = FALSE;

  BOOL foundOrigin = FALSE;

  BOOL primaryIsOrigin = FALSE;

  BOOL rc = TRUE;

  struct bounds_t bounds = { 0 };

  if (count == 0)

  {

    WLog_WARN(TAG, "Monitor configuration empty.");

    return TRUE;

  }

  for (UINT32 x = 0; x < count; x++)

  {

    const rdpMonitor* monitor =

        freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x);

    struct bounds_t cur = {

      .x = monitor->x, .y = monitor->y, .width = monitor->width, .height = monitor->height

    };

    bounds = union_rect(&bounds, &cur);

    if (monitor->is_primary)

    {

      if (havePrimary)

      {

        WLog_ERR(TAG, "Monitor configuration contains multiple primary monitors!");

        rc = FALSE;

      }

      havePrimary = TRUE;

    }

    if ((monitor->x == 0) && (monitor->y == 0))

    {

      if (foundOrigin)

      {

        WLog_ERR(TAG, "Monitor configuration does have multiple origin 0/0");

        rc = FALSE;

      }

      foundOrigin = TRUE;

      primaryIsOrigin = monitor->is_primary != 0;

    }

  }

  if ((bounds.width > 32766) || (bounds.width < 200))

  {

    WLog_ERR(TAG,

             "Monitor configuration virtual desktop width must be 200 <= %" PRId32 " <= 32766",

             bounds.width);

    rc = FALSE;

  }

  if ((bounds.height > 32766) || (bounds.height < 200))

  {

    WLog_ERR(TAG,

             "Monitor configuration virtual desktop height must be 200 <= %" PRId32 " <= 32766",

             bounds.height);

    rc = FALSE;

  }

  if (!havePrimary)

  {

    WLog_ERR(TAG, "Monitor configuration does not contain a primary monitor!");

    rc = FALSE;

  }

  if (!foundOrigin)

  {

    WLog_ERR(TAG, "Monitor configuration must start at 0/0 for first monitor!");

    rc = FALSE;

  }

  if (!primaryIsOrigin)

  {

    WLog_ERR(TAG, "Monitor configuration must start at 0/0 for primary monitor!");

    rc = FALSE;

  }

  return rc;

}

BOOL freerdp_settings_check_client_after_preconnect(const rdpSettings* settings)

{

  wLog* log = WLog_Get(TAG);

  BOOL rc = TRUE;

  log_monitor_configuration(settings, log, WLOG_DEBUG);

  if (freerdp_settings_client_monitors_overlap(settings))

    rc = FALSE;

  if (freerdp_settings_client_monitors_have_gaps(settings))

    rc = FALSE;

  if (!freerdp_settings_client_monitors_check_primary_and_origin(settings))

    rc = FALSE;

  if (!rc)

  {

    DWORD level = WLOG_ERROR;

    WLog_Print(log, level, "Invalid or unsupported monitor configuration detected");

    WLog_Print(log, level, "Check if the configuration is valid.");

    WLog_Print(log, level,

               "If you suspect a bug create a new issue at "

               "https://github.com/FreeRDP/FreeRDP/issues/new");

    WLog_Print(

        log, level,

        "Provide at least the following log lines detailing your monitor configuration:");

    log_monitor_configuration(settings, log, level);

  }

  return rc;

}

BOOL freerdp_settings_set_default_order_support(rdpSettings* settings)

{

  BYTE* OrderSupport = freerdp_settings_get_pointer_writable(settings, FreeRDP_OrderSupport);

  if (!OrderSupport)

    return FALSE;

  ZeroMemory(OrderSupport, 32);

  OrderSupport[NEG_DSTBLT_INDEX] = TRUE;

  OrderSupport[NEG_PATBLT_INDEX] = TRUE;

  OrderSupport[NEG_SCRBLT_INDEX] = TRUE;

  OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;

  OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;

  OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;

  OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;

  OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;

  OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;

  OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;

  OrderSupport[NEG_LINETO_INDEX] = TRUE;

  OrderSupport[NEG_POLYLINE_INDEX] = TRUE;

  OrderSupport[NEG_MEMBLT_INDEX] =

      freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;

  OrderSupport[NEG_MEM3BLT_INDEX] =

      freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;

  OrderSupport[NEG_MEMBLT_V2_INDEX] =

      freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;

  OrderSupport[NEG_MEM3BLT_V2_INDEX] =

      freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled) ? 1 : 0;

  OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;

  OrderSupport[NEG_GLYPH_INDEX_INDEX] =

      freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;

  OrderSupport[NEG_FAST_INDEX_INDEX] =

      freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;

  OrderSupport[NEG_FAST_GLYPH_INDEX] =

      freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE;

  OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE;

  OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE;

  OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;

  OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;

  return TRUE;

}

#if !defined(WITH_FULL_CONFIG_PATH)

static char* freerdp_settings_get_legacy_config_path(void)

{

  char product[sizeof(FREERDP_PRODUCT_STRING)] = { 0 };

  for (size_t i = 0; i < sizeof(product); i++)

    product[i] = (char)tolower(FREERDP_PRODUCT_STRING[i]);

  return GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, product);

}

#endif

char* freerdp_settings_get_config_path(void)

{

  char* path = NULL;

  /* For default FreeRDP continue using same config directory

   * as in old releases.

   * Custom builds use <Vendor>/<Product> as config folder. */

#if !defined(WITH_FULL_CONFIG_PATH)

  if (_stricmp(FREERDP_VENDOR_STRING, FREERDP_PRODUCT_STRING) == 0)

    return freerdp_settings_get_legacy_config_path();

#endif

  char* base = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, FREERDP_VENDOR_STRING);

  if (base)

    path = GetCombinedPath(base, FREERDP_PRODUCT_STRING);

  free(base);

  return path;

}

rdpSettings* freerdp_settings_new(DWORD flags)

{

  char* issuers[] = { "FreeRDP", "FreeRDP-licenser" };

  const BOOL server = (flags & FREERDP_SETTINGS_SERVER_MODE) != 0 ? TRUE : FALSE;

  const BOOL remote = (flags & FREERDP_SETTINGS_REMOTE_MODE) != 0 ? TRUE : FALSE;

  rdpSettings* settings = (rdpSettings*)calloc(1, sizeof(rdpSettings));

  if (!settings)

    return NULL;

  if (!server && !remote)

  {

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdScope,

                                     "https%%3A%%2F%%2F%s%%2F%s%%2Foauth2%%2Fnativeclient"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdAccessTokenFormat,

                                     "ms-appx-web%%3a%%2f%%2fMicrosoft.AAD.BrokerPlugin%%2f%s"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdAccessAadFormat,

                                     "https%%3A%%2F%%2F%s%%2F%s%%2Foauth2%%2Fnativeclient"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdScope,

                                     "https%3A%2F%2Fwww.wvd.microsoft.com%2F.default"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdClientID,

                                     "a85cf173-4192-42f8-81fa-777a763e6e2c"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAzureActiveDirectory,

                                     "login.microsoftonline.com"))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdAadtenantid, "common"))

      goto out_fail;

    if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayAvdUseTenantid, FALSE))

      goto out_fail;

    if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopPhysicalWidth, 1000))

      goto out_fail;

    if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopPhysicalHeight, 1000))

      goto out_fail;

    if (!freerdp_settings_set_uint16(settings, FreeRDP_DesktopOrientation,

                                     ORIENTATION_LANDSCAPE))

      goto out_fail;

    if (!freerdp_settings_set_uint32(settings, FreeRDP_DeviceScaleFactor, 100))

      goto out_fail;

    if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopScaleFactor, 100))

      goto out_fail;

  }

  if (!freerdp_settings_set_uint32(settings, FreeRDP_SurfaceCommandsSupported,

                                   SURFCMDS_SET_SURFACE_BITS | SURFCMDS_STREAM_SURFACE_BITS |

                                       SURFCMDS_FRAME_MARKER))

    goto out_fail;