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

Source (jump to first uncovered line)
/* 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 */
        (void)freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
                                                NULL, 0, cleanup);
        break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
        (void)freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
                                               NULL, 0);
        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 NULL;
}

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: 2025-07-01 06:46

Line	Count	Source (jump to first uncovered line)
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	0	{
8	0	WINPR_ASSERT(dst);
9	0	WINPR_ASSERT(src);
10
11	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
12	0	{
13	0	const struct settings_str_entry* cur = &settings_map[x];
14	0	switch (cur->type)
15	0	{
16	0	case FREERDP_SETTINGS_TYPE_BOOL: /* bool */
17	0	{
18	0	BOOL sval = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)cur->id);
19	0	if (!freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)cur->id, sval))
20	0	return FALSE;
21	0	}
22	0	break;
23	0	case FREERDP_SETTINGS_TYPE_UINT16: /* UINT16 */
24	0	{
25	0	UINT16 sval =
26	0	freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)cur->id);
27	0	if (!freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)cur->id, sval))
28	0	return FALSE;
29	0	}
30	0	break;
31	0	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	0	case FREERDP_SETTINGS_TYPE_UINT32: /* UINT32 */
39	0	{
40	0	UINT32 sval =
41	0	freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)cur->id);
42	0	if (!freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)cur->id, sval))
43	0	return FALSE;
44	0	}
45	0	break;
46	0	case FREERDP_SETTINGS_TYPE_INT32: /* INT32 */
47	0	{
48	0	INT32 sval = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)cur->id);
49	0	if (!freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)cur->id, sval))
50	0	return FALSE;
51	0	}
52	0	break;
53	0	case FREERDP_SETTINGS_TYPE_UINT64: /* UINT64 */
54	0	{
55	0	UINT64 sval =
56	0	freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)cur->id);
57	0	if (!freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)cur->id, sval))
58	0	return FALSE;
59	0	}
60	0	break;
61	0	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	0	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
69	0	{
70	0	const char* sval =
71	0	freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)cur->id);
72	0	size_t len = 0;
73	0	if (sval)
74	0	len = strlen(sval);
75	0	if (!freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
76	0	sval, len, FALSE))
77	0	return FALSE;
78	0	}
79	0	break;
80	0	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
81	0	{
82	0	if (cur->id == FreeRDP_instance)
83	0	{
84	0	const void* sval =
85	0	freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)cur->id);
86	0	if (!freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
87	0	sval))
88	0	return FALSE;
89	0	}
90	0	}
91	0	break;
92	0	default:
93	0	return FALSE;
94	0	}
95	0	}
96	0	return TRUE;
97	0	}
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	0	{
330	0	WINPR_ASSERT(dst);
331
332	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
333	0	{
334	0	const struct settings_str_entry* cur = &settings_map[x];
335	0	switch (cur->type)
336	0	{
337	0	case FREERDP_SETTINGS_TYPE_STRING: /* strings */
338	0	(void)freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id,
339	0	NULL, 0, cleanup);
340	0	break;
341	0	case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
342	0	(void)freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id,
343	0	NULL, 0);
344	0	break;
345	0	default:
346	0	break;
347	0	}
348	0	}
349	0	}
350
351		SSIZE_T freerdp_settings_get_key_for_name(const char* value)
352	0	{
353	0	WINPR_ASSERT(value);
354
355	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
356	0	{
357	0	const struct settings_str_entry* cur = &settings_map[x];
358	0	if (strcmp(value, cur->str) == 0)
359	0	return cur->id;
360	0	}
361	0	return -1;
362	0	}
363
364		SSIZE_T freerdp_settings_get_type_for_name(const char* value)
365	0	{
366	0	WINPR_ASSERT(value);
367
368	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
369	0	{
370	0	const struct settings_str_entry* cur = &settings_map[x];
371	0	if (strcmp(value, cur->str) == 0)
372	0	return cur->type;
373	0	}
374	0	return -1;
375	0	}
376
377		const char* freerdp_settings_get_type_name_for_key(SSIZE_T key)
378	0	{
379	0	const SSIZE_T type = freerdp_settings_get_type_for_key(key);
380	0	return freerdp_settings_get_type_name_for_type(type);
381	0	}
382
383		const char* freerdp_settings_get_type_name_for_type(SSIZE_T type)
384	0	{
385	0	switch (type)
386	0	{
387	0	case FREERDP_SETTINGS_TYPE_BOOL:
388	0	return "FREERDP_SETTINGS_TYPE_BOOL";
389	0	case FREERDP_SETTINGS_TYPE_UINT16:
390	0	return "FREERDP_SETTINGS_TYPE_UINT16";
391	0	case FREERDP_SETTINGS_TYPE_INT16:
392	0	return "FREERDP_SETTINGS_TYPE_INT16";
393	0	case FREERDP_SETTINGS_TYPE_UINT32:
394	0	return "FREERDP_SETTINGS_TYPE_UINT32";
395	0	case FREERDP_SETTINGS_TYPE_INT32:
396	0	return "FREERDP_SETTINGS_TYPE_INT32";
397	0	case FREERDP_SETTINGS_TYPE_UINT64:
398	0	return "FREERDP_SETTINGS_TYPE_UINT64";
399	0	case FREERDP_SETTINGS_TYPE_INT64:
400	0	return "FREERDP_SETTINGS_TYPE_INT64";
401	0	case FREERDP_SETTINGS_TYPE_STRING:
402	0	return "FREERDP_SETTINGS_TYPE_STRING";
403	0	case FREERDP_SETTINGS_TYPE_POINTER:
404	0	return "FREERDP_SETTINGS_TYPE_POINTER";
405	0	default:
406	0	return "FREERDP_SETTINGS_TYPE_UNKNOWN";
407	0	}
408	0	}
409
410		SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
411	0	{
412	0	for (size_t x = 0; x < ARRAYSIZE(settings_map); x++)
413	0	{
414	0	const struct settings_str_entry* cur = &settings_map[x];
415	0	if (cur->id == key)
416	0	return cur->type;
417	0	}
418	0	return -1;
419	0	}
420
421		const char* freerdp_settings_get_name_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->str;
428	0	}
429	0	return NULL;
430	0	}
431
432		BOOL freerdp_settings_copy_item(rdpSettings* dst, const rdpSettings* src, SSIZE_T id)
433	0	{
434	0	WINPR_ASSERT(dst);
435	0	WINPR_ASSERT(src);
436
437	0	const SSIZE_T key = freerdp_settings_get_type_for_key(id);
438	0	switch (key)
439	0	{
440	0	case FREERDP_SETTINGS_TYPE_BOOL:
441	0	{
442	0	const BOOL val = freerdp_settings_get_bool(src, (FreeRDP_Settings_Keys_Bool)id);
443	0	return freerdp_settings_set_bool(dst, (FreeRDP_Settings_Keys_Bool)id, val);
444	0	}
445	0	case FREERDP_SETTINGS_TYPE_INT16:
446	0	{
447	0	const INT16 val = freerdp_settings_get_int16(src, (FreeRDP_Settings_Keys_Int16)id);
448	0	return freerdp_settings_set_int16(dst, (FreeRDP_Settings_Keys_Int16)id, val);
449	0	}
450	0	case FREERDP_SETTINGS_TYPE_INT32:
451	0	{
452	0	const INT32 val = freerdp_settings_get_int32(src, (FreeRDP_Settings_Keys_Int32)id);
453	0	return freerdp_settings_set_int32(dst, (FreeRDP_Settings_Keys_Int32)id, val);
454	0	}
455	0	case FREERDP_SETTINGS_TYPE_INT64:
456	0	{
457	0	const INT64 val = freerdp_settings_get_int64(src, (FreeRDP_Settings_Keys_Int64)id);
458	0	return freerdp_settings_set_int64(dst, (FreeRDP_Settings_Keys_Int64)id, val);
459	0	}
460	0	case FREERDP_SETTINGS_TYPE_UINT16:
461	0	{
462	0	const UINT16 val = freerdp_settings_get_uint16(src, (FreeRDP_Settings_Keys_UInt16)id);
463	0	return freerdp_settings_set_uint16(dst, (FreeRDP_Settings_Keys_UInt16)id, val);
464	0	}
465	0	case FREERDP_SETTINGS_TYPE_UINT32:
466	0	{
467	0	const UINT32 val = freerdp_settings_get_uint32(src, (FreeRDP_Settings_Keys_UInt32)id);
468	0	return freerdp_settings_set_uint32(dst, (FreeRDP_Settings_Keys_UInt32)id, val);
469	0	}
470	0	case FREERDP_SETTINGS_TYPE_UINT64:
471	0	{
472	0	const UINT64 val = freerdp_settings_get_uint64(src, (FreeRDP_Settings_Keys_UInt64)id);
473	0	return freerdp_settings_set_uint64(dst, (FreeRDP_Settings_Keys_UInt64)id, val);
474	0	}
475	0	case FREERDP_SETTINGS_TYPE_STRING:
476	0	{
477	0	const char* val = freerdp_settings_get_string(src, (FreeRDP_Settings_Keys_String)id);
478	0	return freerdp_settings_set_string(dst, (FreeRDP_Settings_Keys_String)id, val);
479	0	}
480	0	case FREERDP_SETTINGS_TYPE_POINTER:
481	0	{
482	0	const void* val = freerdp_settings_get_pointer(src, (FreeRDP_Settings_Keys_Pointer)id);
483	0	return freerdp_settings_set_pointer(dst, (FreeRDP_Settings_Keys_Pointer)id, val);
484	0	}
485	0	default:
486	0	return FALSE;
487	0	}
488	0	}