/**

 * 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/version.h>

#include <freerdp/settings.h>

#include <freerdp/utils/string.h>

#include <freerdp/utils/helpers.h>

#include <freerdp/build-config.h>

#include "../core/utils.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\\%s\\Server"

#define CLIENT_KEY "Software\\%s\\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, nullptr, &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));

}

static void settings_client_load_hkey_local_machine(rdpSettings* settings)

{

  {

    char* key = freerdp_getApplicatonDetailsRegKey(CLIENT_KEY);

    if (key)

    {

      HKEY hKey = nullptr;

      const LONG status =

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

      free(key);

      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);

      }

    }

  }

  {

    char* key = freerdp_getApplicatonDetailsRegKey(BITMAP_CACHE_KEY);

    if (key)

    {

      HKEY hKey = nullptr;

      const LONG status =

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

      free(key);

      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] = WINPR_C_ARRAY_INIT;

          TCHAR persist[64] = WINPR_C_ARRAY_INIT;

          BITMAP_CACHE_V2_CELL_INFO cache = WINPR_C_ARRAY_INIT;

          (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);

      }

    }

  }

  {

    char* key = freerdp_getApplicatonDetailsRegKey(GLYPH_CACHE_KEY);

    if (key)

    {

      HKEY hKey = nullptr;

      const LONG status =

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

      free(key);

      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 = WINPR_C_ARRAY_INIT;

          TCHAR numentries[64] = WINPR_C_ARRAY_INIT;

          TCHAR maxsize[64] = WINPR_C_ARRAY_INIT;

          (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 %u", x);

        }

        {

          GLYPH_CACHE_DEFINITION cache = WINPR_C_ARRAY_INIT;

          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!");

      }

    }

  }

  {

    char* key = freerdp_getApplicatonDetailsRegKey(POINTER_CACHE_KEY);

    if (key)

    {

      HKEY hKey = nullptr;

      const LONG status =

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

      free(key);

      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 = nullptr;

  char* key = freerdp_getApplicatonDetailsRegKey(SERVER_KEY);

  if (!key)

    return;

  const LONG status =

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

  free(key);

  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] = WINPR_C_ARRAY_INIT;

  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] = WINPR_C_ARRAY_INIT;

    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] = WINPR_C_ARRAY_INIT;

      char buffer2[32] = WINPR_C_ARRAY_INIT;

      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)

WINPR_ATTR_NODISCARD

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: %s [%" 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,

             freerdp_desktop_rotation_flags_to_string(monitor->attributes.orientation),

             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 = WINPR_C_ARRAY_INIT;

  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;

}

char* freerdp_settings_get_config_path(void)

{

  return freerdp_GetConfigFilePath(FALSE, "");

}

rdpSettings* freerdp_settings_new(DWORD flags)

{

  const BOOL server = ((flags & FREERDP_SETTINGS_SERVER_MODE) != 0);

  const BOOL remote = ((flags & FREERDP_SETTINGS_REMOTE_MODE) != 0);

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

  if (!settings)

    return nullptr;

  {

    const char* vendor = freerdp_getApplicationDetailsVendor();

    const char* product = freerdp_getApplicationDetailsProduct();

    const char* details = freerdp_getApplicationDetailsString();

    char* issuer1 = nullptr;

    char* issuer2 = nullptr;

    char* issuer3 = nullptr;

    size_t len = 0;

    (void)winpr_asprintf(&issuer1, &len, "%s-licenser", freerdp_getApplicationDetailsString());

    (void)winpr_asprintf(&issuer2, &len, "%s-licenser", freerdp_getApplicationDetailsVendor());

    (void)winpr_asprintf(&issuer3, &len, "%s-licenser", freerdp_getApplicationDetailsProduct());

    char* issuers[] = { WINPR_CAST_CONST_PTR_AWAY(vendor, char*),

                      WINPR_CAST_CONST_PTR_AWAY(product, char*),

                      WINPR_CAST_CONST_PTR_AWAY(details, char*),

                      issuer1,

                      issuer2,

                      issuer3 };

    const BOOL res = freerdp_server_license_issuers_copy(settings, issuers, ARRAYSIZE(issuers));

    free(issuer1);

    free(issuer2);

    free(issuer3);

    if (!res)

      goto out_fail;

  }

  if (!server && !remote)

  {

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayHttpUserAgent,

                                     FREERDP_USER_AGENT))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayHttpMsUserAgent,

                                     FREERDP_USER_AGENT))

      goto out_fail;

    if (!freerdp_settings_set_string(settings, FreeRDP_GatewayHttpReferer, ""))

      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%20openid%"

                                     "20profile%20offline_access"))

      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;