/src/FreeRDP/libfreerdp/common/settings_str.c

Source
/* Generated by  */

#include "../core/settings.h"
#include "settings_str.h"

BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src)
{
  WINPR_ASSERT(dst);
  WINPR_ASSERT(src);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    switch (cur->type)
    {
      case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
      {
        BOOL sval = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)cur->id);
        if (!freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
      {
        UINT16 sval =
            freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)cur->id);
        if (!freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
      {
        INT16 sval = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)cur->id);
        if (!freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
      {
        UINT32 sval =
            freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)cur->id);
        if (!freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
      {
        INT32 sval = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)cur->id);
        if (!freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
      {
        UINT64 sval =
            freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)cur->id);
        if (!freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
      {
        INT64 sval = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)cur->id);
        if (!freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)cur->id, sval))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_STRING: /* strings */
      {
        const char* sval =
            freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)cur->id);
        size_t len = 0;
        if (sval)
          len = strlen(sval);
        if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
                                               sval, len, FALSE))
          return FALSE;
      }
      break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
      {
        if (cur->id == FreeRDP_instance)
        {
          const void* sval =
              freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)cur->id);
          if (!freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
                                            sval))
            return FALSE;
        }
      }
      break;
      default:
        return FALSE;
    }
  }
  return TRUE;
}

BOOL freerdp_settings_print_diff(wLog* log, DWORD level, const rdpSettings* settings,
                                 const rdpSettings* other)
{
  BOOL rc = FALSE;

  WINPR_ASSERT(log);
  WINPR_ASSERT(settings);
  WINPR_ASSERT(other);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    switch (cur->type)
    {
      case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
      {
        BOOL sval =
            freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
        BOOL cval = freerdp_settings_get_bool(other, (FreeRDP_Settings_Keys_Bool)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [BOOL]: %s -> %s", cur->str, sval ? "TRUE" : "FALSE",
                     cval ? "TRUE" : "FALSE");
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
      {
        UINT16 sval =
            freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
        UINT16 cval =
            freerdp_settings_get_uint16(other, (FreeRDP_Settings_Keys_UInt16)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [UINT16]: %" PRIu16 " -> %" PRIu16, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
      {
        INT16 sval =
            freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
        INT16 cval =
            freerdp_settings_get_int16(other, (FreeRDP_Settings_Keys_Int16)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [INT16]: %" PRId16 " -> %" PRId16, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
      {
        UINT32 sval =
            freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
        UINT32 cval =
            freerdp_settings_get_uint32(other, (FreeRDP_Settings_Keys_UInt32)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [UINT32]: %" PRIu32 " -> %" PRIu32, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
      {
        INT32 sval =
            freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
        INT32 cval =
            freerdp_settings_get_int32(other, (FreeRDP_Settings_Keys_Int32)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [INT32]: %" PRId32 " -> %" PRId32, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
      {
        UINT64 sval =
            freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
        UINT64 cval =
            freerdp_settings_get_uint64(other, (FreeRDP_Settings_Keys_UInt64)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [UINT64]: %" PRIu64 " -> %" PRIu64, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
      {
        INT64 sval =
            freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
        INT64 cval =
            freerdp_settings_get_int64(other, (FreeRDP_Settings_Keys_Int64)cur->id);
        if (sval != cval)
        {
          rc = TRUE;
          WLog_Print(log, level, "%s [INT64]: %" PRId64 " -> %" PRId64, cur->str, sval,
                     cval);
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_STRING: /* strings */
      {
        const char* sval =
            freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
        const char* cval =
            freerdp_settings_get_string(other, (FreeRDP_Settings_Keys_String)cur->id);
        if (sval != cval)
        {
          if (!sval || !cval || (strcmp(sval, cval) != 0))
          {
            rc = TRUE;
            WLog_Print(log, level, "%s [STRING]: '%s' -> '%s'", cur->str, sval, cval);
          }
        }
      }
      break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
      {
        const void* sval =
            freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
        const void* cval =
            freerdp_settings_get_pointer(other, (FreeRDP_Settings_Keys_Pointer)cur->id);
        if (sval != cval)
        {
          if ((sval && !cval) || (!sval && cval))
          {
            rc = TRUE;
            WLog_Print(log, level, "%s [POINTER]: '%p' -> '%p'", cur->str, sval, cval);
          }
        }
      }
      break;
      default:
        break;
    }
  }
  return rc;
}

void freerdp_settings_dump(wLog* log, DWORD level, const rdpSettings* settings)
{
  WINPR_ASSERT(log);
  WINPR_ASSERT(settings);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    switch (cur->type)
    {
      case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
      {
        BOOL sval =
            freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
        WLog_Print(log, level, "%s [BOOL]: %s", cur->str, sval ? "TRUE" : "FALSE");
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
      {
        UINT16 sval =
            freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
        WLog_Print(log, level, "%s [UINT16]: %" PRIu16, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
      {
        INT16 sval =
            freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
        WLog_Print(log, level, "%s [INT16]: %" PRId16, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
      {
        UINT32 sval =
            freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
        WLog_Print(log, level, "%s [UINT32]: %" PRIu32, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
      {
        INT32 sval =
            freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
        WLog_Print(log, level, "%s [INT32]: %" PRId32, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
      {
        UINT64 sval =
            freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
        WLog_Print(log, level, "%s [UINT64]: %" PRIu64, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
      {
        INT64 sval =
            freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
        WLog_Print(log, level, "%s [INT64]: %" PRId64, cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_STRING: /* strings */
      {
        const char* sval =
            freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
        WLog_Print(log, level, "%s [STRING]: '%s'", cur->str, sval);
      }
      break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
      {
        const void* sval =
            freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
        WLog_Print(log, level, "%s [POINTER]: '%p'", cur->str, sval);
      }
      break;
      default:
        break;
    }
  }
}

void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup)
{
  WINPR_ASSERT(dst);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    switch (cur->type)
    {
      case FREERDP_SETTINGS_TYPE_STRING: /* strings */
        if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
                                               nullptr, 0, cleanup))
        {
          WLog_WARN(TAG,
                    "freerdp_settings_set_string_copy_(dst, %" PRIdz
                    ", nullptr, 0, %s) failed",
                    cur->id, cleanup ? "true" : "false");
        }
        break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
        if (!freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
                                              nullptr, 0))
        {
          WLog_WARN(
              TAG, "freerdp_settings_set_pointer_len(dst, %" PRIdz ", nullptr, 0) failed",
              cur->id);
        }
        break;
      default:
        break;
    }
  }
}

SSIZE_T freerdp_settings_get_key_for_name(const char* value)
{
  WINPR_ASSERT(value);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    if (strcmp(value, cur->str) == 0)
      return cur->id;
  }
  return -1;
}

SSIZE_T freerdp_settings_get_type_for_name(const char* value)
{
  WINPR_ASSERT(value);

  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    if (strcmp(value, cur->str) == 0)
      return cur->type;
  }
  return -1;
}

const char* freerdp_settings_get_type_name_for_key(SSIZE_T key)
{
  const SSIZE_T type = freerdp_settings_get_type_for_key(key);
  return freerdp_settings_get_type_name_for_type(type);
}

const char* freerdp_settings_get_type_name_for_type(SSIZE_T type)
{
  switch (type)
  {
    case FREERDP_SETTINGS_TYPE_BOOL:
      return "FREERDP_SETTINGS_TYPE_BOOL";
    case FREERDP_SETTINGS_TYPE_UINT16:
      return "FREERDP_SETTINGS_TYPE_UINT16";
    case FREERDP_SETTINGS_TYPE_INT16:
      return "FREERDP_SETTINGS_TYPE_INT16";
    case FREERDP_SETTINGS_TYPE_UINT32:
      return "FREERDP_SETTINGS_TYPE_UINT32";
    case FREERDP_SETTINGS_TYPE_INT32:
      return "FREERDP_SETTINGS_TYPE_INT32";
    case FREERDP_SETTINGS_TYPE_UINT64:
      return "FREERDP_SETTINGS_TYPE_UINT64";
    case FREERDP_SETTINGS_TYPE_INT64:
      return "FREERDP_SETTINGS_TYPE_INT64";
    case FREERDP_SETTINGS_TYPE_STRING:
      return "FREERDP_SETTINGS_TYPE_STRING";
    case FREERDP_SETTINGS_TYPE_POINTER:
      return "FREERDP_SETTINGS_TYPE_POINTER";
    default:
      return "FREERDP_SETTINGS_TYPE_UNKNOWN";
  }
}

SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
{
  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    if (cur->id == key)
      return cur->type;
  }
  return -1;
}

const char* freerdp_settings_get_name_for_key(SSIZE_T key)
{
  for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
  {
    const struct settings_str_entry* cur = &settings_map[x];
    if (cur->id == key)
      return cur->str;
  }
  return nullptr;
}

BOOL freerdp_settings_copy_item(rdpSettings* dst, const rdpSettings* src, SSIZE_T id)
{
  WINPR_ASSERT(dst);
  WINPR_ASSERT(src);

  const SSIZE_T key = freerdp_settings_get_type_for_key(id);
  switch (key)
  {
    case FREERDP_SETTINGS_TYPE_BOOL:
    {
      const BOOL val = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)id);
      return freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)id, val);
    }
    case FREERDP_SETTINGS_TYPE_INT16:
    {
      const INT16 val = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)id);
      return freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)id, val);
    }
    case FREERDP_SETTINGS_TYPE_INT32:
    {
      const INT32 val = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)id);
      return freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)id, val);
    }
    case FREERDP_SETTINGS_TYPE_INT64:
    {
      const INT64 val = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)id);
      return freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)id, val);
    }
    case FREERDP_SETTINGS_TYPE_UINT16:
    {
      const UINT16 val = freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)id);
      return freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)id, val);
    }
    case FREERDP_SETTINGS_TYPE_UINT32:
    {
      const UINT32 val = freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)id);
      return freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)id, val);
    }
    case FREERDP_SETTINGS_TYPE_UINT64:
    {
      const UINT64 val = freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)id);
      return freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)id, val);
    }
    case FREERDP_SETTINGS_TYPE_STRING:
    {
      const char* val = freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)id);
      return freerdp_settings_set_string(dst, (FreeRDP_Settings_Keys_String)id, val);
    }
    case FREERDP_SETTINGS_TYPE_POINTER:
    {
      const void* val = freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)id);
      return freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)id, val);
    }
    default:
      return FALSE;
  }
}

Coverage Report

Created: 2026-04-12 07:03

Line	Count	Source
1		/* Generated by */
2
3		#include "../core/settings.h"
4		#include "settings_str.h"
5
6		BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src)
7	17.7k	{
8	17.7k	WINPR_ASSERT(dst);
9	17.7k	WINPR_ASSERT(src);
10
11	8.48M	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
12	8.46M	{
13	8.46M	const struct settings_str_entry* cur = &settings_map[x];
14	8.46M	switch (cur->type)
15	8.46M	{
16	3.47M	case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
17	3.47M	{
18	3.47M	BOOL sval = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)cur->id);
19	3.47M	if (!freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)cur->id, sval))
20	0	return FALSE;
21	3.47M	}
22	3.47M	break;
23	3.47M	case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
24	230k	{
25	230k	UINT16 sval =
26	230k	freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)cur->id);
27	230k	if (!freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)cur->id, sval))
28	0	return FALSE;
29	230k	}
30	230k	break;
31	230k	case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
32	0	{
33	0	INT16 sval = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)cur->id);
34	0	if (!freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)cur->id, sval))
35	0	return FALSE;
36	0	}
37	0	break;
38	2.21M	case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
39	2.21M	{
40	2.21M	UINT32 sval =
41	2.21M	freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)cur->id);
42	2.21M	if (!freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)cur->id, sval))
43	0	return FALSE;
44	2.21M	}
45	2.21M	break;
46	2.21M	case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
47	71.0k	{
48	71.0k	INT32 sval = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)cur->id);
49	71.0k	if (!freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)cur->id, sval))
50	0	return FALSE;
51	71.0k	}
52	71.0k	break;
53	71.0k	case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
54	35.5k	{
55	35.5k	UINT64 sval =
56	35.5k	freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)cur->id);
57	35.5k	if (!freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)cur->id, sval))
58	0	return FALSE;
59	35.5k	}
60	35.5k	break;
61	35.5k	case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
62	0	{
63	0	INT64 sval = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)cur->id);
64	0	if (!freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)cur->id, sval))
65	0	return FALSE;
66	0	}
67	0	break;
68	1.88M	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
69	1.88M	{
70	1.88M	const char* sval =
71	1.88M	freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)cur->id);
72	1.88M	size_t len = 0;
73	1.88M	if (sval)
74	226k	len = strlen(sval);
75	1.88M	if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
76	1.88M	sval, len, FALSE))
77	0	return FALSE;
78	1.88M	}
79	1.88M	break;
80	1.88M	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
81	550k	{
82	550k	if (cur->id == FreeRDP_instance)
83	17.7k	{
84	17.7k	const void* sval =
85	17.7k	freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)cur->id);
86	17.7k	if (!freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
87	17.7k	sval))
88	0	return FALSE;
89	17.7k	}
90	550k	}
91	550k	break;
92	550k	default:
93	0	return FALSE;
94	8.46M	}
95	8.46M	}
96	17.7k	return TRUE;
97	17.7k	}
98
99		BOOL freerdp_settings_print_diff(wLog* log, DWORD level, const rdpSettings* settings,
100		const rdpSettings* other)
101	0	{
102	0	BOOL rc = FALSE;
103
104	0	WINPR_ASSERT(log);
105	0	WINPR_ASSERT(settings);
106	0	WINPR_ASSERT(other);
107
108	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
109	0	{
110	0	const struct settings_str_entry* cur = &settings_map[x];
111	0	switch (cur->type)
112	0	{
113	0	case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
114	0	{
115	0	BOOL sval =
116	0	freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
117	0	BOOL cval = freerdp_settings_get_bool(other, (FreeRDP_Settings_Keys_Bool)cur->id);
118	0	if (sval != cval)
119	0	{
120	0	rc = TRUE;
121	0	WLog_Print(log, level, "%s [BOOL]: %s -> %s", cur->str, sval ? "TRUE" : "FALSE",
122	0	cval ? "TRUE" : "FALSE");
123	0	}
124	0	}
125	0	break;
126	0	case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
127	0	{
128	0	UINT16 sval =
129	0	freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
130	0	UINT16 cval =
131	0	freerdp_settings_get_uint16(other, (FreeRDP_Settings_Keys_UInt16)cur->id);
132	0	if (sval != cval)
133	0	{
134	0	rc = TRUE;
135	0	WLog_Print(log, level, "%s [UINT16]: %" PRIu16 " -> %" PRIu16, cur->str, sval,
136	0	cval);
137	0	}
138	0	}
139	0	break;
140	0	case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
141	0	{
142	0	INT16 sval =
143	0	freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
144	0	INT16 cval =
145	0	freerdp_settings_get_int16(other, (FreeRDP_Settings_Keys_Int16)cur->id);
146	0	if (sval != cval)
147	0	{
148	0	rc = TRUE;
149	0	WLog_Print(log, level, "%s [INT16]: %" PRId16 " -> %" PRId16, cur->str, sval,
150	0	cval);
151	0	}
152	0	}
153	0	break;
154	0	case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
155	0	{
156	0	UINT32 sval =
157	0	freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
158	0	UINT32 cval =
159	0	freerdp_settings_get_uint32(other, (FreeRDP_Settings_Keys_UInt32)cur->id);
160	0	if (sval != cval)
161	0	{
162	0	rc = TRUE;
163	0	WLog_Print(log, level, "%s [UINT32]: %" PRIu32 " -> %" PRIu32, cur->str, sval,
164	0	cval);
165	0	}
166	0	}
167	0	break;
168	0	case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
169	0	{
170	0	INT32 sval =
171	0	freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
172	0	INT32 cval =
173	0	freerdp_settings_get_int32(other, (FreeRDP_Settings_Keys_Int32)cur->id);
174	0	if (sval != cval)
175	0	{
176	0	rc = TRUE;
177	0	WLog_Print(log, level, "%s [INT32]: %" PRId32 " -> %" PRId32, cur->str, sval,
178	0	cval);
179	0	}
180	0	}
181	0	break;
182	0	case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
183	0	{
184	0	UINT64 sval =
185	0	freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
186	0	UINT64 cval =
187	0	freerdp_settings_get_uint64(other, (FreeRDP_Settings_Keys_UInt64)cur->id);
188	0	if (sval != cval)
189	0	{
190	0	rc = TRUE;
191	0	WLog_Print(log, level, "%s [UINT64]: %" PRIu64 " -> %" PRIu64, cur->str, sval,
192	0	cval);
193	0	}
194	0	}
195	0	break;
196	0	case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
197	0	{
198	0	INT64 sval =
199	0	freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
200	0	INT64 cval =
201	0	freerdp_settings_get_int64(other, (FreeRDP_Settings_Keys_Int64)cur->id);
202	0	if (sval != cval)
203	0	{
204	0	rc = TRUE;
205	0	WLog_Print(log, level, "%s [INT64]: %" PRId64 " -> %" PRId64, cur->str, sval,
206	0	cval);
207	0	}
208	0	}
209	0	break;
210	0	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
211	0	{
212	0	const char* sval =
213	0	freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
214	0	const char* cval =
215	0	freerdp_settings_get_string(other, (FreeRDP_Settings_Keys_String)cur->id);
216	0	if (sval != cval)
217	0	{
218	0	if (!sval \|\| !cval \|\| (strcmp(sval, cval) != 0))
219	0	{
220	0	rc = TRUE;
221	0	WLog_Print(log, level, "%s [STRING]: '%s' -> '%s'", cur->str, sval, cval);
222	0	}
223	0	}
224	0	}
225	0	break;
226	0	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
227	0	{
228	0	const void* sval =
229	0	freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
230	0	const void* cval =
231	0	freerdp_settings_get_pointer(other, (FreeRDP_Settings_Keys_Pointer)cur->id);
232	0	if (sval != cval)
233	0	{
234	0	if ((sval && !cval) \|\| (!sval && cval))
235	0	{
236	0	rc = TRUE;
237	0	WLog_Print(log, level, "%s [POINTER]: '%p' -> '%p'", cur->str, sval, cval);
238	0	}
239	0	}
240	0	}
241	0	break;
242	0	default:
243	0	break;
244	0	}
245	0	}
246	0	return rc;
247	0	}
248
249		void freerdp_settings_dump(wLog* log, DWORD level, const rdpSettings* settings)
250	0	{
251	0	WINPR_ASSERT(log);
252	0	WINPR_ASSERT(settings);
253
254	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
255	0	{
256	0	const struct settings_str_entry* cur = &settings_map[x];
257	0	switch (cur->type)
258	0	{
259	0	case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
260	0	{
261	0	BOOL sval =
262	0	freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)cur->id);
263	0	WLog_Print(log, level, "%s [BOOL]: %s", cur->str, sval ? "TRUE" : "FALSE");
264	0	}
265	0	break;
266	0	case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
267	0	{
268	0	UINT16 sval =
269	0	freerdp_settings_get_uint16(settings, (FreeRDP_Settings_Keys_UInt16)cur->id);
270	0	WLog_Print(log, level, "%s [UINT16]: %" PRIu16, cur->str, sval);
271	0	}
272	0	break;
273	0	case FREERDP_SETTINGS_TYPE_INT16: /* INT16 */
274	0	{
275	0	INT16 sval =
276	0	freerdp_settings_get_int16(settings, (FreeRDP_Settings_Keys_Int16)cur->id);
277	0	WLog_Print(log, level, "%s [INT16]: %" PRId16, cur->str, sval);
278	0	}
279	0	break;
280	0	case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
281	0	{
282	0	UINT32 sval =
283	0	freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)cur->id);
284	0	WLog_Print(log, level, "%s [UINT32]: %" PRIu32, cur->str, sval);
285	0	}
286	0	break;
287	0	case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
288	0	{
289	0	INT32 sval =
290	0	freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)cur->id);
291	0	WLog_Print(log, level, "%s [INT32]: %" PRId32, cur->str, sval);
292	0	}
293	0	break;
294	0	case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
295	0	{
296	0	UINT64 sval =
297	0	freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)cur->id);
298	0	WLog_Print(log, level, "%s [UINT64]: %" PRIu64, cur->str, sval);
299	0	}
300	0	break;
301	0	case FREERDP_SETTINGS_TYPE_INT64: /* INT64 */
302	0	{
303	0	INT64 sval =
304	0	freerdp_settings_get_int64(settings, (FreeRDP_Settings_Keys_Int64)cur->id);
305	0	WLog_Print(log, level, "%s [INT64]: %" PRId64, cur->str, sval);
306	0	}
307	0	break;
308	0	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
309	0	{
310	0	const char* sval =
311	0	freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)cur->id);
312	0	WLog_Print(log, level, "%s [STRING]: '%s'", cur->str, sval);
313	0	}
314	0	break;
315	0	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
316	0	{
317	0	const void* sval =
318	0	freerdp_settings_get_pointer(settings, (FreeRDP_Settings_Keys_Pointer)cur->id);
319	0	WLog_Print(log, level, "%s [POINTER]: '%p'", cur->str, sval);
320	0	}
321	0	break;
322	0	default:
323	0	break;
324	0	}
325	0	}
326	0	}
327
328		void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup)
329	106k	{
330	106k	WINPR_ASSERT(dst);
331
332	50.9M	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
333	50.8M	{
334	50.8M	const struct settings_str_entry* cur = &settings_map[x];
335	50.8M	switch (cur->type)
336	50.8M	{
337	11.2M	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
338	11.2M	if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
339	11.2M	nullptr, 0, cleanup))
340	0	{
341	0	WLog_WARN(TAG,
342	0	"freerdp_settings_set_string_copy_(dst, %" PRIdz
343	0	", nullptr, 0, %s) failed",
344	0	cur->id, cleanup ? "true" : "false");
345	0	}
346	11.2M	break;
347	3.30M	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
348	3.30M	if (!freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
349	3.30M	nullptr, 0))
350	0	{
351	0	WLog_WARN(
352	0	TAG, "freerdp_settings_set_pointer_len(dst, %" PRIdz ", nullptr, 0) failed",
353	0	cur->id);
354	0	}
355	3.30M	break;
356	36.2M	default:
357	36.2M	break;
358	50.8M	}
359	50.8M	}
360	106k	}
361
362		SSIZE_T freerdp_settings_get_key_for_name(const char* value)
363	0	{
364	0	WINPR_ASSERT(value);
365
366	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
367	0	{
368	0	const struct settings_str_entry* cur = &settings_map[x];
369	0	if (strcmp(value, cur->str) == 0)
370	0	return cur->id;
371	0	}
372	0	return -1;
373	0	}
374
375		SSIZE_T freerdp_settings_get_type_for_name(const char* value)
376	0	{
377	0	WINPR_ASSERT(value);
378
379	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
380	0	{
381	0	const struct settings_str_entry* cur = &settings_map[x];
382	0	if (strcmp(value, cur->str) == 0)
383	0	return cur->type;
384	0	}
385	0	return -1;
386	0	}
387
388		const char* freerdp_settings_get_type_name_for_key(SSIZE_T key)
389	0	{
390	0	const SSIZE_T type = freerdp_settings_get_type_for_key(key);
391	0	return freerdp_settings_get_type_name_for_type(type);
392	0	}
393
394		const char* freerdp_settings_get_type_name_for_type(SSIZE_T type)
395	0	{
396	0	switch (type)
397	0	{
398	0	case FREERDP_SETTINGS_TYPE_BOOL:
399	0	return "FREERDP_SETTINGS_TYPE_BOOL";
400	0	case FREERDP_SETTINGS_TYPE_UINT16:
401	0	return "FREERDP_SETTINGS_TYPE_UINT16";
402	0	case FREERDP_SETTINGS_TYPE_INT16:
403	0	return "FREERDP_SETTINGS_TYPE_INT16";
404	0	case FREERDP_SETTINGS_TYPE_UINT32:
405	0	return "FREERDP_SETTINGS_TYPE_UINT32";
406	0	case FREERDP_SETTINGS_TYPE_INT32:
407	0	return "FREERDP_SETTINGS_TYPE_INT32";
408	0	case FREERDP_SETTINGS_TYPE_UINT64:
409	0	return "FREERDP_SETTINGS_TYPE_UINT64";
410	0	case FREERDP_SETTINGS_TYPE_INT64:
411	0	return "FREERDP_SETTINGS_TYPE_INT64";
412	0	case FREERDP_SETTINGS_TYPE_STRING:
413	0	return "FREERDP_SETTINGS_TYPE_STRING";
414	0	case FREERDP_SETTINGS_TYPE_POINTER:
415	0	return "FREERDP_SETTINGS_TYPE_POINTER";
416	0	default:
417	0	return "FREERDP_SETTINGS_TYPE_UNKNOWN";
418	0	}
419	0	}
420
421		SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
422	0	{
423	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
424	0	{
425	0	const struct settings_str_entry* cur = &settings_map[x];
426	0	if (cur->id == key)
427	0	return cur->type;
428	0	}
429	0	return -1;
430	0	}
431
432		const char* freerdp_settings_get_name_for_key(SSIZE_T key)
433	0	{
434	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
435	0	{
436	0	const struct settings_str_entry* cur = &settings_map[x];
437	0	if (cur->id == key)
438	0	return cur->str;
439	0	}
440	0	return nullptr;
441	0	}
442
443		BOOL freerdp_settings_copy_item(rdpSettings* dst, const rdpSettings* src, SSIZE_T id)
444	0	{
445	0	WINPR_ASSERT(dst);
446	0	WINPR_ASSERT(src);
447
448	0	const SSIZE_T key = freerdp_settings_get_type_for_key(id);
449	0	switch (key)
450	0	{
451	0	case FREERDP_SETTINGS_TYPE_BOOL:
452	0	{
453	0	const BOOL val = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)id);
454	0	return freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)id, val);
455	0	}
456	0	case FREERDP_SETTINGS_TYPE_INT16:
457	0	{
458	0	const INT16 val = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)id);
459	0	return freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)id, val);
460	0	}
461	0	case FREERDP_SETTINGS_TYPE_INT32:
462	0	{
463	0	const INT32 val = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)id);
464	0	return freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)id, val);
465	0	}
466	0	case FREERDP_SETTINGS_TYPE_INT64:
467	0	{
468	0	const INT64 val = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)id);
469	0	return freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)id, val);
470	0	}
471	0	case FREERDP_SETTINGS_TYPE_UINT16:
472	0	{
473	0	const UINT16 val = freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)id);
474	0	return freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)id, val);
475	0	}
476	0	case FREERDP_SETTINGS_TYPE_UINT32:
477	0	{
478	0	const UINT32 val = freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)id);
479	0	return freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)id, val);
480	0	}
481	0	case FREERDP_SETTINGS_TYPE_UINT64:
482	0	{
483	0	const UINT64 val = freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)id);
484	0	return freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)id, val);
485	0	}
486	0	case FREERDP_SETTINGS_TYPE_STRING:
487	0	{
488	0	const char* val = freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)id);
489	0	return freerdp_settings_set_string(dst, (FreeRDP_Settings_Keys_String)id, val);
490	0	}
491	0	case FREERDP_SETTINGS_TYPE_POINTER:
492	0	{
493	0	const void* val = freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)id);
494	0	return freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)id, val);
495	0	}
496	0	default:
497	0	return FALSE;
498	0	}
499	0	}