/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 */
      {
        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;
    }
  }
  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;
    }
  }
  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;
    }
  }
}

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 */
        freerdp_settings_set_string_copy_(dst, (FreeRDP_Settings_Keys_String)cur->id, NULL,
                                          0, cleanup);
        break;
      case FREERDP_SETTINGS_TYPE_POINTER: /* pointer */
        freerdp_settings_set_pointer_len(dst, (FreeRDP_Settings_Keys_Pointer)cur->id, NULL,
                                         0);
        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: 2024-09-08 06:20

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