Adding upstream version 3.3.0+dfsg1.upstream/3.3.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 10084 insertions, 0 deletions

diff --git a/libfreerdp/common/CMakeLists.txt b/libfreerdp/common/CMakeLists.txt
new file mode 100644
index 0000000..36cda87
--- /dev/null
+++ b/libfreerdp/common/CMakeLists.txt
@@ -0,0 +1,33 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# libfreerdp-common cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(MODULE_NAME "freerdp-common")
+set(MODULE_PREFIX "FREERDP_COMMON")
+
+set(${MODULE_PREFIX}_SRCS
+	addin.c
+	settings.c
+	settings_getters.c
+	settings_str.c
+	settings_str.h
+	assistance.c)
+
+freerdp_module_add(${${MODULE_PREFIX}_SRCS})
+
+if(BUILD_TESTING)
+	add_subdirectory(test)
+endif()
diff --git a/libfreerdp/common/addin.c b/libfreerdp/common/addin.c
new file mode 100644
index 0000000..9c5cd1f
--- /dev/null
+++ b/libfreerdp/common/addin.c
@@ -0,0 +1,397 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Addin Loader
+ *
+ * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <winpr/crt.h>
+#include <winpr/path.h>
+#include <winpr/string.h>
+#include <winpr/library.h>
+
+#include <freerdp/addin.h>
+#include <freerdp/build-config.h>
+
+#include <freerdp/log.h>
+#define TAG FREERDP_TAG("addin")
+
+static INLINE BOOL is_path_required(LPCSTR path, size_t len)
+{
+	if (!path || (len <= 1))
+		return FALSE;
+
+	if (strcmp(path, ".") == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+LPSTR freerdp_get_library_install_path(void)
+{
+	LPSTR pszPath = NULL;
+	size_t cchPath = 0;
+	size_t cchLibraryPath = 0;
+	size_t cchInstallPrefix = 0;
+	BOOL needLibPath = 0;
+	BOOL needInstallPath = 0;
+	LPCSTR pszLibraryPath = FREERDP_LIBRARY_PATH;
+	LPCSTR pszInstallPrefix = FREERDP_INSTALL_PREFIX;
+	cchLibraryPath = strlen(pszLibraryPath) + 1;
+	cchInstallPrefix = strlen(pszInstallPrefix) + 1;
+	cchPath = cchInstallPrefix + cchLibraryPath;
+	needInstallPath = is_path_required(pszInstallPrefix, cchInstallPrefix);
+	needLibPath = is_path_required(pszLibraryPath, cchLibraryPath);
+
+	if (!needInstallPath && !needLibPath)
+		return NULL;
+
+	pszPath = (LPSTR)malloc(cchPath + 1);
+
+	if (!pszPath)
+		return NULL;
+
+	if (needInstallPath)
+	{
+		CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
+		pszPath[cchInstallPrefix] = '\0';
+	}
+
+	if (needLibPath)
+	{
+		if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszLibraryPath)))
+		{
+			free(pszPath);
+			return NULL;
+		}
+	}
+
+	return pszPath;
+}
+
+LPSTR freerdp_get_dynamic_addin_install_path(void)
+{
+#if defined(WITH_ADD_PLUGIN_TO_RPATH)
+	return NULL;
+#else
+	LPSTR pszPath = NULL;
+	size_t cchPath = 0;
+	size_t cchAddinPath = 0;
+	size_t cchInstallPrefix = 0;
+	BOOL needLibPath = 0;
+	BOOL needInstallPath = 0;
+	LPCSTR pszAddinPath = FREERDP_ADDIN_PATH;
+	LPCSTR pszInstallPrefix = FREERDP_INSTALL_PREFIX;
+	cchAddinPath = strlen(pszAddinPath) + 1;
+	cchInstallPrefix = strlen(pszInstallPrefix) + 1;
+	cchPath = cchInstallPrefix + cchAddinPath;
+	needInstallPath = is_path_required(pszInstallPrefix, cchInstallPrefix);
+	needLibPath = is_path_required(pszAddinPath, cchAddinPath);
+
+	WLog_DBG(TAG,
+	         "freerdp_get_dynamic_addin_install_path <- pszInstallPrefix: %s, pszAddinPath: %s",
+	         pszInstallPrefix, pszAddinPath);
+
+	if (!needInstallPath && !needLibPath)
+		return NULL;
+
+	pszPath = (LPSTR)calloc(cchPath + 1, sizeof(CHAR));
+
+	if (!pszPath)
+		return NULL;
+
+	if (needInstallPath)
+	{
+		CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
+		pszPath[cchInstallPrefix] = '\0';
+	}
+
+	if (needLibPath)
+	{
+		if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszAddinPath)))
+		{
+			free(pszPath);
+			return NULL;
+		}
+	}
+
+	WLog_DBG(TAG, "freerdp_get_dynamic_addin_install_path -> pszPath: %s", pszPath);
+
+	return pszPath;
+#endif
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_dynamic_addin(LPCSTR pszFileName, LPCSTR pszPath,
+                                                LPCSTR pszEntryName)
+{
+	LPSTR pszAddinInstallPath = freerdp_get_dynamic_addin_install_path();
+	PVIRTUALCHANNELENTRY entry = NULL;
+	BOOL bHasExt = TRUE;
+	PCSTR pszExt = NULL;
+	size_t cchExt = 0;
+	HINSTANCE library = NULL;
+	size_t cchFileName = 0;
+	size_t cchFilePath = 0;
+	LPSTR pszAddinFile = NULL;
+	LPSTR pszFilePath = NULL;
+	LPSTR pszRelativeFilePath = NULL;
+	size_t cchAddinFile = 0;
+	size_t cchAddinInstallPath = 0;
+
+	if (!pszFileName || !pszEntryName)
+		goto fail;
+
+	WLog_DBG(TAG, "freerdp_load_dynamic_addin <- pszFileName: %s, pszPath: %s, pszEntryName: %s",
+	         pszFileName, pszPath, pszEntryName);
+
+	cchFileName = strlen(pszFileName);
+
+	/* Get file name with prefix and extension */
+	if (FAILED(PathCchFindExtensionA(pszFileName, cchFileName + 1, &pszExt)))
+	{
+		pszExt = PathGetSharedLibraryExtensionA(PATH_SHARED_LIB_EXT_WITH_DOT);
+		cchExt = strlen(pszExt);
+		bHasExt = FALSE;
+	}
+
+	if (bHasExt)
+	{
+		pszAddinFile = _strdup(pszFileName);
+
+		if (!pszAddinFile)
+			goto fail;
+	}
+	else
+	{
+		cchAddinFile = cchFileName + cchExt + 2 + sizeof(FREERDP_SHARED_LIBRARY_PREFIX);
+		pszAddinFile = (LPSTR)malloc(cchAddinFile + 1);
+
+		if (!pszAddinFile)
+			goto fail;
+
+		sprintf_s(pszAddinFile, cchAddinFile, FREERDP_SHARED_LIBRARY_PREFIX "%s%s", pszFileName,
+		          pszExt);
+	}
+
+	cchAddinFile = strlen(pszAddinFile);
+
+	/* If a path is provided prefix the library name with it. */
+	if (pszPath)
+	{
+		size_t relPathLen = strlen(pszPath) + cchAddinFile + 1;
+		pszRelativeFilePath = calloc(relPathLen, sizeof(CHAR));
+
+		if (!pszRelativeFilePath)
+			goto fail;
+
+		sprintf_s(pszRelativeFilePath, relPathLen, "%s", pszPath);
+		const HRESULT hr = NativePathCchAppendA(pszRelativeFilePath, relPathLen, pszAddinFile);
+		if (FAILED(hr))
+			goto fail;
+	}
+	else
+		pszRelativeFilePath = _strdup(pszAddinFile);
+
+	if (!pszRelativeFilePath)
+		goto fail;
+
+	/* If a system prefix path is provided try these locations too. */
+	if (pszAddinInstallPath)
+	{
+		cchAddinInstallPath = strlen(pszAddinInstallPath);
+		cchFilePath = cchAddinInstallPath + cchFileName + 32;
+		pszFilePath = (LPSTR)malloc(cchFilePath + 1);
+
+		if (!pszFilePath)
+			goto fail;
+
+		CopyMemory(pszFilePath, pszAddinInstallPath, cchAddinInstallPath);
+		pszFilePath[cchAddinInstallPath] = '\0';
+		const HRESULT hr =
+		    NativePathCchAppendA((LPSTR)pszFilePath, cchFilePath + 1, pszRelativeFilePath);
+		if (FAILED(hr))
+			goto fail;
+	}
+	else
+		pszFilePath = _strdup(pszRelativeFilePath);
+
+	library = LoadLibraryX(pszFilePath);
+
+	if (!library)
+		goto fail;
+
+	entry = (PVIRTUALCHANNELENTRY)GetProcAddress(library, pszEntryName);
+fail:
+	free(pszRelativeFilePath);
+	free(pszAddinFile);
+	free(pszFilePath);
+	free(pszAddinInstallPath);
+
+	if (!entry && library)
+		FreeLibrary(library);
+
+	return entry;
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPCSTR pszSubsystem,
+                                                              LPCSTR pszType, DWORD dwFlags)
+{
+	PVIRTUALCHANNELENTRY entry = NULL;
+	LPSTR pszFileName = NULL;
+	const size_t cchBaseFileName = sizeof(FREERDP_SHARED_LIBRARY_PREFIX) + 32;
+	size_t nameLen = 0;
+	size_t subsystemLen = 0;
+	size_t typeLen = 0;
+	size_t cchFileName = 0;
+
+	if (pszName)
+		nameLen = strnlen(pszName, MAX_PATH);
+	if (pszSubsystem)
+		subsystemLen = strnlen(pszSubsystem, MAX_PATH);
+	if (pszType)
+		typeLen = strnlen(pszType, MAX_PATH);
+
+	if (pszName && pszSubsystem && pszType)
+	{
+		cchFileName = cchBaseFileName + nameLen + subsystemLen + typeLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		sprintf_s(pszFileName, cchFileName, "%s-client-%s-%s", pszName, pszSubsystem, pszType);
+	}
+	else if (pszName && pszSubsystem)
+	{
+		cchFileName = cchBaseFileName + nameLen + subsystemLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		sprintf_s(pszFileName, cchFileName, "%s-client-%s", pszName, pszSubsystem);
+	}
+	else if (pszName)
+	{
+		cchFileName = cchBaseFileName + nameLen;
+		pszFileName = (LPSTR)malloc(cchFileName);
+
+		if (!pszFileName)
+			return NULL;
+
+		sprintf_s(pszFileName, cchFileName, "%s-client", pszName);
+	}
+	else
+	{
+		return NULL;
+	}
+
+	{
+		LPCSTR pszExtension = PathGetSharedLibraryExtensionA(0);
+		const char pszPrefix[] = FREERDP_SHARED_LIBRARY_PREFIX;
+		int rc = 0;
+
+		cchFileName += strnlen(pszPrefix, ARRAYSIZE(pszPrefix));
+		if (pszExtension)
+			cchFileName += strnlen(pszExtension, MAX_PATH) + 1;
+		LPSTR tmp = calloc(cchFileName, sizeof(CHAR));
+		if (tmp)
+			rc = sprintf_s(tmp, cchFileName, "%s%s.%s", pszPrefix, pszFileName, pszExtension);
+
+		free(pszFileName);
+		pszFileName = tmp;
+		if (!pszFileName || (rc < 0))
+		{
+			free(pszFileName);
+			return NULL;
+		}
+	}
+
+	if (pszSubsystem)
+	{
+		LPSTR pszEntryName = NULL;
+		size_t cchEntryName = 0;
+		/* subsystem add-in */
+		cchEntryName = 64 + nameLen;
+		pszEntryName = (LPSTR)malloc(cchEntryName + 1);
+
+		if (!pszEntryName)
+		{
+			free(pszFileName);
+			return NULL;
+		}
+
+		sprintf_s(pszEntryName, cchEntryName + 1, "freerdp_%s_client_subsystem_entry", pszName);
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszEntryName);
+		free(pszEntryName);
+		free(pszFileName);
+		return entry;
+	}
+
+	/* channel add-in */
+
+	if (dwFlags & FREERDP_ADDIN_CHANNEL_STATIC)
+	{
+		if (dwFlags & FREERDP_ADDIN_CHANNEL_ENTRYEX)
+			entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntryEx");
+		else
+			entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntry");
+	}
+	else if (dwFlags & FREERDP_ADDIN_CHANNEL_DYNAMIC)
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DVCPluginEntry");
+	else if (dwFlags & FREERDP_ADDIN_CHANNEL_DEVICE)
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DeviceServiceEntry");
+	else
+		entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszType);
+
+	free(pszFileName);
+	return entry;
+}
+
+static FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN freerdp_load_static_channel_addin_entry = NULL;
+
+int freerdp_register_addin_provider(FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN provider, DWORD dwFlags)
+{
+	freerdp_load_static_channel_addin_entry = provider;
+	return 0;
+}
+
+FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN freerdp_get_current_addin_provider(void)
+{
+	return freerdp_load_static_channel_addin_entry;
+}
+
+PVIRTUALCHANNELENTRY freerdp_load_channel_addin_entry(LPCSTR pszName, LPCSTR pszSubsystem,
+                                                      LPCSTR pszType, DWORD dwFlags)
+{
+	PVIRTUALCHANNELENTRY entry = NULL;
+
+	if (freerdp_load_static_channel_addin_entry)
+		entry = freerdp_load_static_channel_addin_entry(pszName, pszSubsystem, pszType, dwFlags);
+
+	if (!entry)
+		entry = freerdp_load_dynamic_channel_addin_entry(pszName, pszSubsystem, pszType, dwFlags);
+
+	if (!entry)
+		WLog_WARN(TAG, "Failed to load channel %s [%s]", pszName, pszSubsystem);
+
+	return entry;
+}
diff --git a/libfreerdp/common/assistance.c b/libfreerdp/common/assistance.c
new file mode 100644
index 0000000..dc76d6a
--- /dev/null
+++ b/libfreerdp/common/assistance.c
@@ -0,0 +1,1490 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Remote Assistance
+ *
+ * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+
+#include <winpr/wtypes.h>
+#include <winpr/collections.h>
+#include <winpr/string.h>
+#include <winpr/crt.h>
+#include <winpr/crypto.h>
+#include <winpr/print.h>
+#include <winpr/windows.h>
+#include <winpr/ssl.h>
+#include <winpr/file.h>
+
+#include <freerdp/log.h>
+#include <freerdp/client/file.h>
+#include <freerdp/client/cmdline.h>
+
+#include <freerdp/assistance.h>
+
+#include "../core/settings.h"
+
+#define TAG FREERDP_TAG("common")
+
+struct rdp_assistance_file
+{
+	UINT32 Type;
+
+	char* Username;
+	char* LHTicket;
+	char* RCTicket;
+	char* PassStub;
+	UINT32 DtStart;
+	UINT32 DtLength;
+	BOOL LowSpeed;
+	BOOL RCTicketEncrypted;
+
+	char* ConnectionString1;
+	char* ConnectionString2;
+
+	BYTE* EncryptedPassStub;
+	size_t EncryptedPassStubLength;
+
+	BYTE* EncryptedLHTicket;
+	size_t EncryptedLHTicketLength;
+
+	wArrayList* MachineAddresses;
+	wArrayList* MachinePorts;
+	wArrayList* MachineUris;
+
+	char* RASessionId;
+	char* RASpecificParams;
+	char* RASpecificParams2;
+
+	char* filename;
+	char* password;
+};
+
+static const char* strrstr(const char* haystack, size_t len, const char* needle)
+{
+	if (*needle == '\0')
+		return (const char*)haystack;
+
+	char* result = NULL;
+	for (;;)
+	{
+		char* p = strstr(haystack, needle);
+		if (p == NULL)
+			break;
+		if (p > haystack + len)
+			return NULL;
+
+		result = p;
+		haystack = p + 1;
+	}
+
+	return result;
+}
+
+static BOOL update_option(char** opt, const char* val, size_t len)
+{
+	WINPR_ASSERT(opt);
+	free(*opt);
+	*opt = NULL;
+
+	if (!val && (len != 0))
+		return FALSE;
+	else if (!val && (len == 0))
+		return TRUE;
+	*opt = strndup(val, len);
+	return *opt != NULL;
+}
+
+static BOOL update_name(rdpAssistanceFile* file, const char* name)
+{
+	WINPR_ASSERT(file);
+
+	if (!name)
+	{
+		WLog_ERR(TAG, "ASSISTANCE file %s invalid name", name);
+		return FALSE;
+	}
+
+	free(file->filename);
+	file->filename = _strdup(name);
+	return file->filename != NULL;
+}
+
+static BOOL update_password(rdpAssistanceFile* file, const char* password)
+{
+	WINPR_ASSERT(file);
+	free(file->password);
+	file->password = NULL;
+	if (!password)
+		return TRUE;
+	file->password = _strdup(password);
+	return file->password != NULL;
+}
+
+static BOOL update_connectionstring2_nocopy(rdpAssistanceFile* file, char* str)
+{
+	WINPR_ASSERT(file);
+	free(file->ConnectionString2);
+	file->ConnectionString2 = NULL;
+	if (!str)
+		return TRUE;
+	file->ConnectionString2 = str;
+	return file->ConnectionString2 != NULL;
+}
+
+static BOOL update_connectionstring2(rdpAssistanceFile* file, const char* str, size_t len)
+{
+	char* strc = NULL;
+	if (!str && (len != 0))
+		return FALSE;
+
+	if (str && (len > 0))
+	{
+		strc = strndup(str, len);
+		if (!strc)
+			return FALSE;
+	}
+	return update_connectionstring2_nocopy(file, strc);
+}
+
+static BOOL update_connectionstring2_wchar(rdpAssistanceFile* file, const WCHAR* str, size_t len)
+{
+	char* strc = NULL;
+
+	if (!str && (len != 0))
+		return FALSE;
+
+	if (str && (len > 0))
+	{
+		strc = ConvertWCharNToUtf8Alloc(str, len, NULL);
+		if (!strc)
+			return FALSE;
+	}
+	return update_connectionstring2_nocopy(file, strc);
+}
+
+/**
+ * Password encryption in establishing a remote assistance session of type 1:
+ * http://blogs.msdn.com/b/openspecification/archive/2011/10/31/password-encryption-in-establishing-a-remote-assistance-session-of-type-1.aspx
+ *
+ * Creation of PassStub for the Remote Assistance Ticket:
+ * http://social.msdn.microsoft.com/Forums/en-US/6316c3f4-ea09-4343-a4a1-9cca46d70d28/creation-of-passstub-for-the-remote-assistance-ticket?forum=os_windowsprotocols
+ */
+
+/**
+ * CryptDeriveKey Function:
+ * http://msdn.microsoft.com/en-us/library/windows/desktop/aa379916/
+ *
+ * Let n be the required derived key length, in bytes.
+ * The derived key is the first n bytes of the hash value after the hash computation
+ * has been completed by CryptDeriveKey. If the hash is not a member of the SHA-2
+ * family and the required key is for either 3DES or AES, the key is derived as follows:
+ *
+ * Form a 64-byte buffer by repeating the constant 0x36 64 times.
+ * Let k be the length of the hash value that is represented by the input parameter hBaseData.
+ * Set the first k bytes of the buffer to the result of an XOR operation of the first k bytes
+ * of the buffer with the hash value that is represented by the input parameter hBaseData.
+ *
+ * Form a 64-byte buffer by repeating the constant 0x5C 64 times.
+ * Set the first k bytes of the buffer to the result of an XOR operation of the first k bytes
+ * of the buffer with the hash value that is represented by the input parameter hBaseData.
+ *
+ * Hash the result of step 1 by using the same hash algorithm as that used to compute the hash
+ * value that is represented by the hBaseData parameter.
+ *
+ * Hash the result of step 2 by using the same hash algorithm as that used to compute the hash
+ * value that is represented by the hBaseData parameter.
+ *
+ * Concatenate the result of step 3 with the result of step 4.
+ * Use the first n bytes of the result of step 5 as the derived key.
+ */
+
+static BOOL freerdp_assistance_crypt_derive_key_sha1(BYTE* hash, size_t hashLength, BYTE* key,
+                                                     size_t keyLength)
+{
+	BOOL rc = FALSE;
+	BYTE pad1[64] = { 0 };
+	BYTE pad2[64] = { 0 };
+
+	memset(pad1, 0x36, sizeof(pad1));
+	memset(pad2, 0x5C, sizeof(pad2));
+
+	for (size_t i = 0; i < hashLength; i++)
+	{
+		pad1[i] ^= hash[i];
+		pad2[i] ^= hash[i];
+	}
+
+	BYTE* buffer = (BYTE*)calloc(hashLength, 2);
+
+	if (!buffer)
+		goto fail;
+
+	if (!winpr_Digest(WINPR_MD_SHA1, pad1, 64, buffer, hashLength))
+		goto fail;
+
+	if (!winpr_Digest(WINPR_MD_SHA1, pad2, 64, &buffer[hashLength], hashLength))
+		goto fail;
+
+	CopyMemory(key, buffer, keyLength);
+	rc = TRUE;
+fail:
+	free(buffer);
+	return rc;
+}
+
+static BOOL append_address_to_list(wArrayList* MachineAddresses, const char* str, size_t len)
+{
+	char* copy = NULL;
+	if (len > 0)
+		copy = strndup(str, len);
+	if (!copy)
+		return FALSE;
+
+	const BOOL rc = ArrayList_Append(MachineAddresses, copy);
+	if (!rc)
+		free(copy);
+	// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append takes ownership of copy
+	return rc;
+}
+
+static BOOL append_address(rdpAssistanceFile* file, const char* host, const char* port)
+{
+	WINPR_ASSERT(file);
+
+	errno = 0;
+	unsigned long p = strtoul(port, NULL, 0);
+
+	if ((errno != 0) || (p == 0) || (p > UINT16_MAX))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 invalid port value %s",
+		         port);
+		return FALSE;
+	}
+
+	if (!append_address_to_list(file->MachineAddresses, host, host ? strlen(host) : 0))
+		return FALSE;
+	return ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p);
+}
+
+static BOOL freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
+{
+	WINPR_ASSERT(file);
+
+	WLog_DBG(TAG, "freerdp_assistance_parse_address_list list=%s", list);
+
+	BOOL rc = FALSE;
+
+	if (!list)
+		return FALSE;
+
+	char* strp = list;
+	char* s = ";";
+
+	// get the first token
+	char* token = strtok(strp, s);
+
+	// walk through other tokens
+	while (token != NULL)
+	{
+		char* port = strchr(token, ':');
+		if (!port)
+			goto out;
+		*port = '\0';
+		port++;
+
+		if (!append_address(file, token, port))
+			goto out;
+
+		token = strtok(NULL, s);
+	}
+	rc = TRUE;
+out:
+	return rc;
+}
+
+static BOOL freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
+{
+	char* tokens[8] = { 0 };
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(file);
+
+	if (!file->RCTicket)
+		return FALSE;
+
+	/**
+	 * <ProtocolVersion>,<protocolType>,<machineAddressList>,<assistantAccountPwd>,
+	 * <RASessionID>,<RASessionName>,<RASessionPwd>,<protocolSpecificParms>
+	 */
+	char* str = _strdup(file->RCTicket);
+
+	if (!str)
+		goto error;
+
+	const size_t length = strlen(str);
+
+	int count = 1;
+	for (size_t i = 0; i < length; i++)
+	{
+		if (str[i] == ',')
+			count++;
+	}
+
+	if (count != 8)
+		goto error;
+
+	count = 0;
+	tokens[count++] = str;
+
+	for (size_t i = 0; i < length; i++)
+	{
+		if (str[i] == ',')
+		{
+			str[i] = '\0';
+			tokens[count++] = &str[i + 1];
+		}
+	}
+
+	if (strcmp(tokens[0], "65538") != 0)
+		goto error;
+
+	if (strcmp(tokens[1], "1") != 0)
+		goto error;
+
+	if (strcmp(tokens[3], "*") != 0)
+		goto error;
+
+	if (strcmp(tokens[5], "*") != 0)
+		goto error;
+
+	if (strcmp(tokens[6], "*") != 0)
+		goto error;
+
+	file->RASessionId = _strdup(tokens[4]);
+
+	if (!file->RASessionId)
+		goto error;
+
+	file->RASpecificParams = _strdup(tokens[7]);
+
+	if (!file->RASpecificParams)
+		goto error;
+
+	if (!freerdp_assistance_parse_address_list(file, tokens[2]))
+		goto error;
+
+	rc = TRUE;
+error:
+	free(str);
+	return rc;
+}
+
+/**
+ * Decrypted Connection String 2:
+ *
+ * <E>
+ * <A KH="BNRjdu97DyczQSRuMRrDWoue+HA="
+ * ID="+ULZ6ifjoCa6cGPMLQiGHRPwkg6VyJqGwxMnO6GcelwUh9a6/FBq3It5ADSndmLL"/> <C> <T ID="1" SID="0"> <L
+ * P="49228" N="fe80::1032:53d9:5a01:909b%3"/> <L P="49229" N="fe80::3d8f:9b2d:6b4e:6aa%6"/> <L
+ * P="49230" N="192.168.1.200"/> <L P="49231" N="169.254.6.170"/>
+ * </T>
+ * </C>
+ * </E>
+ */
+
+static BOOL freerdp_assistance_parse_attr(const char** opt, size_t* plength, const char* key,
+                                          const char* tag)
+{
+	WINPR_ASSERT(opt);
+	WINPR_ASSERT(plength);
+	WINPR_ASSERT(key);
+
+	*opt = NULL;
+	*plength = 0;
+	if (!tag)
+		return FALSE;
+
+	char bkey[128] = { 0 };
+	const int rc = _snprintf(bkey, sizeof(bkey), "%s=\"", key);
+	WINPR_ASSERT(rc > 0);
+	WINPR_ASSERT(rc < sizeof(bkey));
+
+	char* p = strstr(tag, bkey);
+	if (!p)
+		return TRUE;
+
+	p += strlen(bkey);
+	char* q = strchr(p, '"');
+
+	if (!q)
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 invalid field '%s=%s'",
+		         key, p);
+		return FALSE;
+	}
+
+	if (p > q)
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: ConnectionString2 invalid field "
+		         "order for '%s'",
+		         key);
+		return FALSE;
+	}
+	const size_t length = q - p;
+	*opt = p;
+	*plength = length;
+
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_attr_str(char** opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+	return update_option(opt, copt, size);
+}
+
+static BOOL freerdp_assistance_parse_attr_bool(BOOL* opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+
+	WINPR_ASSERT(opt);
+	*opt = FALSE;
+
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+	if (size != 1)
+		return TRUE;
+
+	*opt = (copt[0] == '1');
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_attr_uint32(UINT32* opt, const char* key, const char* tag)
+{
+	const char* copt = NULL;
+	size_t size = 0;
+
+	WINPR_ASSERT(opt);
+	*opt = 0;
+
+	if (!freerdp_assistance_parse_attr(&copt, &size, key, tag))
+		return FALSE;
+
+	char buffer[64] = { 0 };
+	if (size >= sizeof(buffer))
+	{
+		WLog_WARN(TAG, "Invalid UINT32 string '%s' [%" PRIuz "]", copt, size);
+		return FALSE;
+	}
+
+	strncpy(buffer, copt, size);
+	errno = 0;
+	unsigned long val = strtoul(buffer, NULL, 0);
+
+	if ((errno != 0) || (val > UINT32_MAX))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Invalid value %s", buffer);
+		return FALSE;
+	}
+
+	*opt = val;
+
+	return TRUE;
+}
+
+static char* freerdp_assistance_contains_element(char* input, size_t ilen, const char* key,
+                                                 size_t* plen, char** pdata, size_t* pdlen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(plen);
+
+	char bkey[128] = { 0 };
+	const int rc = _snprintf(bkey, sizeof(bkey), "<%s", key);
+	WINPR_ASSERT(rc > 0);
+	WINPR_ASSERT(rc < sizeof(bkey));
+
+	char* tag = strstr(input, bkey);
+	if (!tag || (tag > input + ilen))
+		return NULL;
+
+	char* data = tag + strnlen(bkey, sizeof(bkey));
+
+	/* Ensure there is a valid delimiter following our token */
+	switch (data[0])
+	{
+		case '>':
+		case '/':
+		case ' ':
+		case '\t':
+			break;
+		default:
+			WLog_ERR(TAG,
+			         "Failed to parse ASSISTANCE file: ConnectionString2 missing delimiter after "
+			         "field %s",
+			         bkey);
+			return NULL;
+	}
+
+	char* start = strstr(tag, ">");
+
+	if (!start || (start > input + ilen))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: ConnectionString2 missing field %s", bkey);
+		return NULL;
+	}
+
+	const char* end = start;
+	const char* dend = start - 1;
+	if (*dend != '/')
+	{
+		char ekey[128] = { 0 };
+		const int erc = _snprintf(ekey, sizeof(ekey), "</%s>", key);
+		WINPR_ASSERT(erc > 0);
+		WINPR_ASSERT(erc < sizeof(ekey));
+		const size_t offset = start - tag;
+		dend = end = strrstr(start, ilen - offset, ekey);
+		if (end)
+			end += strnlen(ekey, sizeof(ekey));
+	}
+
+	if (!end)
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: ConnectionString2 missing end tag for field %s",
+		         key);
+		return NULL;
+	}
+	if (plen)
+		*plen = end - tag;
+
+	if (pdata)
+		*pdata = data;
+	if (pdlen)
+		*pdlen = dend - data;
+	return tag;
+}
+
+/**! \brief this function returns a XML element identified by \b key
+ * The input string will be manipulated, so that the element found is '\0' terminated.
+ *
+ * This function can not find multiple elements on the same level as the input string is changed!
+ */
+static BOOL freerdp_assistance_consume_input_and_get_element(char* input, const char* key,
+                                                             char** element, size_t* elen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(element);
+	WINPR_ASSERT(elen);
+
+	size_t len = 0;
+	size_t dlen = 0;
+	char* data = NULL;
+	char* tag = freerdp_assistance_contains_element(input, strlen(input), key, &len, &data, &dlen);
+	if (!tag)
+		return FALSE;
+
+	char* end = data + dlen;
+	*tag = '\0';
+	*end = '\0';
+	*element = data;
+	*elen = dlen + 1;
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_get_element(char* input, size_t ilen, const char* key,
+                                           char** element, size_t* elen)
+{
+	WINPR_ASSERT(input);
+	WINPR_ASSERT(key);
+	WINPR_ASSERT(element);
+	WINPR_ASSERT(elen);
+
+	size_t len = 0;
+	size_t dlen = 0;
+	char* data = NULL;
+	char* tag = freerdp_assistance_contains_element(input, ilen, key, &len, &data, &dlen);
+	if (!tag)
+		return FALSE;
+
+	if (tag + len > input + ilen)
+		return FALSE;
+
+	char* end = tag + len;
+	*element = data;
+	*elen = end - data + 1;
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of(rdpAssistanceFile* file, char* data,
+                                                     size_t len, const char* key,
+                                                     BOOL (*fkt)(rdpAssistanceFile* file,
+                                                                 char* data, size_t len))
+{
+	char* val = NULL;
+	size_t vlen = 0;
+
+	while (freerdp_assistance_get_element(data, len, key, &val, &vlen))
+	{
+		data = val + vlen;
+		len = strnlen(data, len);
+		if (vlen > 0)
+		{
+			val[vlen - 1] = '\0';
+
+			if (!fkt(file, val, vlen))
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_l(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	UINT32 p = 0;
+	const char* n = NULL;
+	const char* u = NULL;
+	size_t nlen = 0;
+	size_t ulen = 0;
+	if (!freerdp_assistance_parse_attr_uint32(&p, "P", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr(&n, &nlen, "N", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr(&u, &ulen, "U", data))
+		return FALSE;
+
+	if (n && (nlen > 0))
+	{
+		if (!append_address_to_list(file->MachineAddresses, n, nlen))
+			return FALSE;
+		if (!ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p))
+			return FALSE;
+	}
+	if (u && (ulen > 0))
+	{
+		if (!append_address_to_list(file->MachineAddresses, u, ulen))
+			return FALSE;
+		if (!ArrayList_Append(file->MachinePorts, (void*)(uintptr_t)p))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_t(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	UINT32 id = 0;
+	UINT32 sid = 0;
+	if (!freerdp_assistance_parse_attr_uint32(&id, "ID", data))
+		return FALSE;
+	if (!freerdp_assistance_parse_attr_uint32(&sid, "SID", data))
+		return FALSE;
+	WLog_DBG(TAG, "transport id=%" PRIu32 ", sid=%" PRIu32, id, sid);
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "L",
+	                                                freerdp_assistance_parse_all_elements_of_l);
+}
+
+static BOOL freerdp_assistance_parse_all_elements_of_c(rdpAssistanceFile* file, char* data,
+                                                       size_t len)
+{
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "T",
+	                                                freerdp_assistance_parse_all_elements_of_t);
+}
+
+static BOOL freerdp_assistance_parse_find_elements_of_c(rdpAssistanceFile* file, char* data,
+                                                        size_t len)
+{
+	return freerdp_assistance_parse_all_elements_of(file, data, len, "C",
+	                                                freerdp_assistance_parse_all_elements_of_c);
+}
+
+static BOOL freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
+{
+	BOOL rc = FALSE;
+
+	WINPR_ASSERT(file);
+
+	if (!file->ConnectionString2)
+		return FALSE;
+
+	char* str = _strdup(file->ConnectionString2);
+	if (!str)
+		goto out_fail;
+
+	char* e = NULL;
+	size_t elen = 0;
+	if (!freerdp_assistance_consume_input_and_get_element(str, "E", &e, &elen))
+		goto out_fail;
+
+	if (!e || (elen == 0))
+		goto out_fail;
+
+	char* a = NULL;
+	size_t alen = 0;
+	if (!freerdp_assistance_get_element(e, elen, "A", &a, &alen))
+		goto out_fail;
+
+	if (!a || (alen == 0))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_find_elements_of_c(file, e, elen))
+		goto out_fail;
+
+	/* '\0' terminate the detected XML elements so
+	 * the parser can continue with terminated strings
+	 */
+	a[alen] = '\0';
+	if (!freerdp_assistance_parse_attr_str(&file->RASpecificParams, "KH", a))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_attr_str(&file->RASpecificParams2, "KH2", a))
+		goto out_fail;
+
+	if (!freerdp_assistance_parse_attr_str(&file->RASessionId, "ID", a))
+		goto out_fail;
+
+	rc = TRUE;
+out_fail:
+	free(str);
+	return rc;
+}
+
+char* freerdp_assistance_construct_expert_blob(const char* name, const char* pass)
+{
+	size_t size = 0;
+	size_t nameLength = 0;
+	size_t passLength = 0;
+	char* ExpertBlob = NULL;
+
+	if (!name || !pass)
+		return NULL;
+
+	nameLength = strlen(name) + strlen("NAME=");
+	passLength = strlen(pass) + strlen("PASS=");
+	size = nameLength + passLength + 64;
+	ExpertBlob = (char*)calloc(1, size);
+
+	if (!ExpertBlob)
+		return NULL;
+
+	sprintf_s(ExpertBlob, size, "%" PRIdz ";NAME=%s%" PRIdz ";PASS=%s", nameLength, name,
+	          passLength, pass);
+	return ExpertBlob;
+}
+
+char* freerdp_assistance_generate_pass_stub(DWORD flags)
+{
+	UINT32 nums[14];
+	char* passStub = NULL;
+	char set1[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789*_";
+	char set2[12] = "!@#$&^*()-+=";
+	char set3[10] = "0123456789";
+	char set4[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	char set5[26] = "abcdefghijklmnopqrstuvwxyz";
+	passStub = (char*)malloc(15);
+
+	if (!passStub)
+		return NULL;
+
+	/**
+	 * PassStub generation:
+	 *
+	 * Characters 0 and 5-13 are from the set A-Z a-z 0-9 * _
+	 * Character 1 is from the set !@#$&^*()-+=
+	 * Character 2 is from the set 0-9
+	 * Character 3 is from the set A-Z
+	 * Character 4 is from the set a-z
+	 *
+	 * Example: WB^6HsrIaFmEpi
+	 */
+	winpr_RAND(nums, sizeof(nums));
+	passStub[0] = set1[nums[0] % sizeof(set1)];   /* character 0 */
+	passStub[1] = set2[nums[1] % sizeof(set2)];   /* character 1 */
+	passStub[2] = set3[nums[2] % sizeof(set3)];   /* character 2 */
+	passStub[3] = set4[nums[3] % sizeof(set4)];   /* character 3 */
+	passStub[4] = set5[nums[4] % sizeof(set5)];   /* character 4 */
+	passStub[5] = set1[nums[5] % sizeof(set1)];   /* character 5 */
+	passStub[6] = set1[nums[6] % sizeof(set1)];   /* character 6 */
+	passStub[7] = set1[nums[7] % sizeof(set1)];   /* character 7 */
+	passStub[8] = set1[nums[8] % sizeof(set1)];   /* character 8 */
+	passStub[9] = set1[nums[9] % sizeof(set1)];   /* character 9 */
+	passStub[10] = set1[nums[10] % sizeof(set1)]; /* character 10 */
+	passStub[11] = set1[nums[11] % sizeof(set1)]; /* character 11 */
+	passStub[12] = set1[nums[12] % sizeof(set1)]; /* character 12 */
+	passStub[13] = set1[nums[13] % sizeof(set1)]; /* character 13 */
+	passStub[14] = '\0';
+	return passStub;
+}
+
+BYTE* freerdp_assistance_encrypt_pass_stub(const char* password, const char* passStub,
+                                           size_t* pEncryptedSize)
+{
+	BOOL rc = 0;
+	size_t cbPasswordW = 0;
+	size_t cbPassStubW = 0;
+	size_t EncryptedSize = 0;
+	BYTE PasswordHash[WINPR_MD5_DIGEST_LENGTH];
+	WINPR_CIPHER_CTX* rc4Ctx = NULL;
+	BYTE* pbIn = NULL;
+	BYTE* pbOut = NULL;
+	size_t cbOut = 0;
+	size_t cbIn = 0;
+	size_t cbFinal = 0;
+	WCHAR* PasswordW = ConvertUtf8ToWCharAlloc(password, &cbPasswordW);
+	WCHAR* PassStubW = ConvertUtf8ToWCharAlloc(passStub, &cbPassStubW);
+
+	if (!PasswordW || !PassStubW)
+		goto fail;
+
+	cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
+	cbPassStubW = (cbPassStubW) * sizeof(WCHAR);
+	if (!winpr_Digest(WINPR_MD_MD5, (BYTE*)PasswordW, cbPasswordW, (BYTE*)PasswordHash,
+	                  sizeof(PasswordHash)))
+		goto fail;
+
+	EncryptedSize = cbPassStubW + 4;
+	pbIn = (BYTE*)calloc(1, EncryptedSize);
+	pbOut = (BYTE*)calloc(1, EncryptedSize);
+
+	if (!pbIn || !pbOut)
+		goto fail;
+
+	*((UINT32*)pbIn) = (UINT32)cbPassStubW;
+	CopyMemory(&pbIn[4], PassStubW, cbPassStubW);
+	rc4Ctx = winpr_Cipher_New(WINPR_CIPHER_ARC4_128, WINPR_ENCRYPT, PasswordHash, NULL);
+
+	if (!rc4Ctx)
+	{
+		WLog_ERR(TAG, "winpr_Cipher_New failure");
+		goto fail;
+	}
+
+	cbOut = cbFinal = 0;
+	cbIn = EncryptedSize;
+	rc = winpr_Cipher_Update(rc4Ctx, pbIn, cbIn, pbOut, &cbOut);
+
+	if (!rc)
+	{
+		WLog_ERR(TAG, "winpr_Cipher_Update failure");
+		goto fail;
+	}
+
+	if (!winpr_Cipher_Final(rc4Ctx, pbOut + cbOut, &cbFinal))
+	{
+		WLog_ERR(TAG, "winpr_Cipher_Final failure");
+		goto fail;
+	}
+
+	winpr_Cipher_Free(rc4Ctx);
+	free(pbIn);
+	free(PasswordW);
+	free(PassStubW);
+	*pEncryptedSize = EncryptedSize;
+	return pbOut;
+fail:
+	winpr_Cipher_Free(rc4Ctx);
+	free(PasswordW);
+	free(PassStubW);
+	free(pbIn);
+	free(pbOut);
+	return NULL;
+}
+
+static BOOL freerdp_assistance_decrypt2(rdpAssistanceFile* file)
+{
+	BOOL rc = FALSE;
+	int status = 0;
+	size_t cbPasswordW = 0;
+	size_t cchOutW = 0;
+	WINPR_CIPHER_CTX* aesDec = NULL;
+	WCHAR* PasswordW = NULL;
+	BYTE* pbIn = NULL;
+	BYTE* pbOut = NULL;
+	size_t cbOut = 0;
+	size_t cbIn = 0;
+	size_t cbFinal = 0;
+	BYTE DerivedKey[WINPR_AES_BLOCK_SIZE] = { 0 };
+	BYTE InitializationVector[WINPR_AES_BLOCK_SIZE] = { 0 };
+	BYTE PasswordHash[WINPR_SHA1_DIGEST_LENGTH] = { 0 };
+
+	WINPR_ASSERT(file);
+
+	if (!file->password)
+		return FALSE;
+
+	PasswordW = ConvertUtf8ToWCharAlloc(file->password, &cbPasswordW);
+	if (!PasswordW)
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Conversion from UCS2 to UTF8 failed");
+		return FALSE;
+	}
+
+	cbPasswordW = (cbPasswordW) * sizeof(WCHAR);
+
+	if (!winpr_Digest(WINPR_MD_SHA1, (BYTE*)PasswordW, cbPasswordW, PasswordHash,
+	                  sizeof(PasswordHash)))
+		goto fail;
+
+	if (!freerdp_assistance_crypt_derive_key_sha1(PasswordHash, sizeof(PasswordHash), DerivedKey,
+	                                              sizeof(DerivedKey)))
+		goto fail;
+
+	aesDec =
+	    winpr_Cipher_New(WINPR_CIPHER_AES_128_CBC, WINPR_DECRYPT, DerivedKey, InitializationVector);
+
+	if (!aesDec)
+		goto fail;
+
+	cbOut = cbFinal = 0;
+	cbIn = (size_t)file->EncryptedLHTicketLength;
+	pbIn = (BYTE*)file->EncryptedLHTicket;
+	pbOut = (BYTE*)calloc(1, cbIn + WINPR_AES_BLOCK_SIZE + 2);
+
+	if (!pbOut)
+		goto fail;
+
+	if (!winpr_Cipher_Update(aesDec, pbIn, cbIn, pbOut, &cbOut))
+		goto fail;
+
+	if (!winpr_Cipher_Final(aesDec, pbOut + cbOut, &cbFinal))
+	{
+		WLog_ERR(TAG, "winpr_Cipher_Final failure");
+		goto fail;
+	}
+
+	cbOut += cbFinal;
+	cbFinal = 0;
+
+	union
+	{
+		const WCHAR* wc;
+		const BYTE* b;
+	} cnv;
+
+	cnv.b = pbOut;
+	cchOutW = cbOut / sizeof(WCHAR);
+
+	if (!update_connectionstring2_wchar(file, cnv.wc, cchOutW))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Conversion from UCS2 to UTF8 failed");
+		goto fail;
+	}
+
+	if (!freerdp_assistance_parse_connection_string2(file))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	winpr_Cipher_Free(aesDec);
+	free(PasswordW);
+	free(pbOut);
+	WLog_DBG(TAG, "freerdp_assistance_parse_connection_string2: %d", status);
+	return rc;
+}
+
+BYTE* freerdp_assistance_hex_string_to_bin(const void* raw, size_t* size)
+{
+	BYTE* buffer = NULL;
+	if (!raw || !size)
+		return NULL;
+	*size = 0;
+	const size_t length = strlen(raw);
+	buffer = calloc(length, sizeof(BYTE));
+	if (!buffer)
+		return NULL;
+	const size_t rc = winpr_HexStringToBinBuffer(raw, length, buffer, length);
+	if (rc == 0)
+	{
+		free(buffer);
+		return NULL;
+	}
+	*size = rc;
+	return buffer;
+}
+
+char* freerdp_assistance_bin_to_hex_string(const void* raw, size_t size)
+{
+	return winpr_BinToHexString(raw, size, FALSE);
+}
+
+static int freerdp_assistance_parse_uploadinfo(rdpAssistanceFile* file, char* uploadinfo,
+                                               size_t uploadinfosize)
+{
+	const char escalated[9] = "Escalated";
+	const size_t esclen = sizeof(escalated);
+	const char* typestr = NULL;
+	size_t typelen = 0;
+
+	if (!uploadinfo || (uploadinfosize == 0))
+		return -1;
+
+	if (strnlen(uploadinfo, uploadinfosize) == uploadinfosize)
+	{
+		WLog_WARN(TAG, "UPLOADINFOR string is not '\0' terminated");
+		return -1;
+	}
+
+	if (!freerdp_assistance_parse_attr(&typestr, &typelen, "TYPE", uploadinfo))
+		return -1;
+
+	if ((typelen != esclen) || (strncmp(typestr, escalated, esclen) != 0))
+	{
+		WLog_ERR(TAG,
+		         "Failed to parse ASSISTANCE file: Missing or invalid UPLOADINFO TYPE '%s' [%" PRIuz
+		         "]",
+		         typestr, typelen);
+		return -1;
+	}
+
+	char* uploaddata = NULL;
+	size_t uploaddatasize = 0;
+	if (!freerdp_assistance_consume_input_and_get_element(uploadinfo, "UPLOADDATA", &uploaddata,
+	                                                      &uploaddatasize))
+		return -1;
+
+	/* Parse USERNAME */
+	if (!freerdp_assistance_parse_attr_str(&file->Username, "USERNAME", uploaddata))
+		return -1;
+
+	/* Parse LHTICKET */
+	if (!freerdp_assistance_parse_attr_str(&file->LHTicket, "LHTICKET", uploaddata))
+		return -1;
+
+	/* Parse RCTICKET */
+	if (!freerdp_assistance_parse_attr_str(&file->RCTicket, "RCTICKET", uploaddata))
+		return -1;
+
+	/* Parse RCTICKETENCRYPTED */
+	if (!freerdp_assistance_parse_attr_bool(&file->RCTicketEncrypted, "RCTICKETENCRYPTED",
+	                                        uploaddata))
+		return -1;
+
+	/* Parse PassStub */
+	if (!freerdp_assistance_parse_attr_str(&file->PassStub, "PassStub", uploaddata))
+		return -1;
+
+	if (file->PassStub)
+	{
+		const char* amp = "&amp;";
+		char* passtub = strstr(file->PassStub, amp);
+		while (passtub)
+		{
+			const char* end = passtub + 5;
+			const size_t len = strlen(end);
+			memmove(&passtub[1], end, len + 1);
+			passtub = strstr(passtub, amp);
+		}
+	}
+
+	/* Parse DtStart */
+	if (!freerdp_assistance_parse_attr_uint32(&file->DtStart, "DtStart", uploaddata))
+		return -1;
+
+	/* Parse DtLength */
+	if (!freerdp_assistance_parse_attr_uint32(&file->DtLength, "DtLength", uploaddata))
+		return -1;
+
+	/* Parse L (LowSpeed) */
+	if (!freerdp_assistance_parse_attr_bool(&file->LowSpeed, "L", uploaddata))
+		return -1;
+
+	file->Type = (file->LHTicket) ? 2 : 1;
+	int status = 0;
+
+	switch (file->Type)
+	{
+		case 2:
+		{
+			file->EncryptedLHTicket = freerdp_assistance_hex_string_to_bin(
+			    file->LHTicket, &file->EncryptedLHTicketLength);
+
+			if (!freerdp_assistance_decrypt2(file))
+				status = -1;
+		}
+		break;
+
+		case 1:
+		{
+			if (!freerdp_assistance_parse_connection_string1(file))
+				status = -1;
+		}
+		break;
+
+		default:
+			return -1;
+	}
+
+	if (status < 0)
+	{
+		WLog_ERR(TAG, "freerdp_assistance_parse_connection_string1 failure: %d", status);
+		return -1;
+	}
+
+	file->EncryptedPassStub = freerdp_assistance_encrypt_pass_stub(file->password, file->PassStub,
+	                                                               &file->EncryptedPassStubLength);
+
+	if (!file->EncryptedPassStub)
+		return -1;
+
+	return 1;
+}
+
+static int freerdp_assistance_parse_file_buffer_int(rdpAssistanceFile* file, char* buffer,
+                                                    size_t size, const char* password)
+{
+	WINPR_ASSERT(file);
+	WINPR_ASSERT(buffer);
+	WINPR_ASSERT(size > 0);
+
+	if (!update_password(file, password))
+		return -1;
+
+	char* uploadinfo = NULL;
+	size_t uploadinfosize = 0;
+	if (freerdp_assistance_consume_input_and_get_element(buffer, "UPLOADINFO", &uploadinfo,
+	                                                     &uploadinfosize))
+		return freerdp_assistance_parse_uploadinfo(file, uploadinfo, uploadinfosize);
+
+	size_t elen = 0;
+	const char* estr = freerdp_assistance_contains_element(buffer, size, "E", &elen, NULL, NULL);
+	if (!estr || (elen == 0))
+	{
+		WLog_ERR(TAG, "Failed to parse ASSISTANCE file: Neither UPLOADINFO nor <E> found");
+		return -1;
+	}
+	if (!update_connectionstring2(file, estr, elen))
+		return -1;
+
+	if (!freerdp_assistance_parse_connection_string2(file))
+		return -1;
+
+	return 1;
+}
+
+int freerdp_assistance_parse_file_buffer(rdpAssistanceFile* file, const char* cbuffer, size_t size,
+                                         const char* password)
+{
+	WINPR_ASSERT(file);
+	if (!password)
+	{
+		WLog_WARN(TAG, "empty password supplied");
+	}
+
+	if (!cbuffer || (size == 0))
+	{
+		WLog_WARN(TAG, "no data supplied [%p, %" PRIuz "]", cbuffer, size);
+		return -1;
+	}
+
+	char* abuffer = strndup(cbuffer, size);
+	const size_t len = strnlen(cbuffer, size);
+	if (len == size)
+		WLog_WARN(TAG, "Input data not '\0' terminated");
+
+	if (!abuffer)
+		return -1;
+
+	const int rc = freerdp_assistance_parse_file_buffer_int(file, abuffer, len + 1, password);
+	free(abuffer);
+	return rc;
+}
+
+int freerdp_assistance_parse_file(rdpAssistanceFile* file, const char* name, const char* password)
+{
+	int status = 0;
+	BYTE* buffer = NULL;
+	FILE* fp = NULL;
+	size_t readSize = 0;
+	union
+	{
+		INT64 i64;
+		size_t s;
+	} fileSize;
+
+	if (!update_name(file, name))
+		return -1;
+
+	fp = winpr_fopen(name, "r");
+
+	if (!fp)
+	{
+		WLog_ERR(TAG, "Failed to open ASSISTANCE file %s ", name);
+		return -1;
+	}
+
+	_fseeki64(fp, 0, SEEK_END);
+	fileSize.i64 = _ftelli64(fp);
+	_fseeki64(fp, 0, SEEK_SET);
+
+	if (fileSize.i64 < 1)
+	{
+		WLog_ERR(TAG, "Failed to read ASSISTANCE file %s ", name);
+		fclose(fp);
+		return -1;
+	}
+
+	buffer = (BYTE*)malloc(fileSize.s + 2);
+
+	if (!buffer)
+	{
+		fclose(fp);
+		return -1;
+	}
+
+	readSize = fread(buffer, fileSize.s, 1, fp);
+
+	if (!readSize)
+	{
+		if (!ferror(fp))
+			readSize = fileSize.s;
+	}
+
+	fclose(fp);
+
+	if (readSize < 1)
+	{
+		WLog_ERR(TAG, "Failed to read ASSISTANCE file %s ", name);
+		free(buffer);
+		buffer = NULL;
+		return -1;
+	}
+
+	buffer[fileSize.s] = '\0';
+	buffer[fileSize.s + 1] = '\0';
+	status = freerdp_assistance_parse_file_buffer(file, (char*)buffer, fileSize.s, password);
+	free(buffer);
+	return status;
+}
+
+BOOL freerdp_assistance_populate_settings_from_assistance_file(rdpAssistanceFile* file,
+                                                               rdpSettings* settings)
+{
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteAssistanceMode, TRUE))
+		return FALSE;
+
+	if (!file->RASessionId || !file->MachineAddresses)
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceSessionId,
+	                                 file->RASessionId))
+		return FALSE;
+
+	if (file->RCTicket)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceRCTicket,
+		                                 file->RCTicket))
+			return FALSE;
+	}
+	else
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistanceRCTicket,
+		                                 file->ConnectionString2))
+			return FALSE;
+	}
+
+	if (file->PassStub)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistancePassStub,
+		                                 file->PassStub))
+			return FALSE;
+	}
+
+	if (ArrayList_Count(file->MachineAddresses) < 1)
+		return FALSE;
+
+	const char* addr = ArrayList_GetItem(file->MachineAddresses, 0);
+	if (!freerdp_settings_set_string(settings, FreeRDP_ServerHostname, addr))
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_AssistanceFile, file->filename))
+		return FALSE;
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_RemoteAssistancePassword, file->password))
+		return FALSE;
+
+	if (file->Username)
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_Username, file->Username))
+			return FALSE;
+	}
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteAssistanceMode, TRUE))
+		return FALSE;
+
+	const size_t ports = ArrayList_Count(file->MachinePorts);
+	const size_t addresses = ArrayList_Count(file->MachineAddresses);
+	if (ports < 1)
+		return FALSE;
+	if (ports != addresses)
+		return FALSE;
+
+	const UINT32 port = (UINT32)ArrayList_GetItem(file->MachinePorts, 0);
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, port))
+		return FALSE;
+
+	if (!freerdp_target_net_adresses_reset(settings, ports))
+		return FALSE;
+
+	for (size_t x = 0; x < ports; x++)
+	{
+		const UINT32 port = (UINT32)ArrayList_GetItem(file->MachinePorts, x);
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetPorts, x, &port))
+			return FALSE;
+	}
+	for (size_t i = 0; i < addresses; i++)
+	{
+		const char* maddr = ArrayList_GetItem(file->MachineAddresses, i);
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i, maddr))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL setup_string(wArrayList* list)
+{
+	WINPR_ASSERT(list);
+
+	wObject* obj = ArrayList_Object(list);
+	if (!obj)
+		return FALSE;
+	obj->fnObjectFree = free;
+	// obj->fnObjectNew = wwinpr_ObjectStringClone;
+	return TRUE;
+}
+
+rdpAssistanceFile* freerdp_assistance_file_new(void)
+{
+	winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
+	rdpAssistanceFile* file = calloc(1, sizeof(rdpAssistanceFile));
+	if (!file)
+		return NULL;
+
+	file->MachineAddresses = ArrayList_New(FALSE);
+	file->MachinePorts = ArrayList_New(FALSE);
+	file->MachineUris = ArrayList_New(FALSE);
+
+	if (!file->MachineAddresses || !file->MachinePorts || !file->MachineUris)
+		goto fail;
+
+	if (!setup_string(file->MachineAddresses) || !setup_string(file->MachineUris))
+		goto fail;
+
+	return file;
+
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_assistance_file_free(file);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+
+void freerdp_assistance_file_free(rdpAssistanceFile* file)
+{
+	if (!file)
+		return;
+
+	update_password(file, NULL);
+	update_connectionstring2(file, NULL, 0);
+	free(file->filename);
+	free(file->Username);
+	free(file->LHTicket);
+	free(file->RCTicket);
+	free(file->PassStub);
+	free(file->ConnectionString1);
+	free(file->EncryptedLHTicket);
+	free(file->RASessionId);
+	free(file->RASpecificParams);
+	free(file->RASpecificParams2);
+	free(file->EncryptedPassStub);
+
+	ArrayList_Free(file->MachineAddresses);
+	ArrayList_Free(file->MachinePorts);
+	ArrayList_Free(file->MachineUris);
+	free(file);
+}
+
+void freerdp_assistance_print_file(rdpAssistanceFile* file, wLog* log, DWORD level)
+{
+	WINPR_ASSERT(file);
+
+	WLog_Print(log, level, "Username: %s", file->Username);
+	WLog_Print(log, level, "LHTicket: %s", file->LHTicket);
+	WLog_Print(log, level, "RCTicket: %s", file->RCTicket);
+	WLog_Print(log, level, "RCTicketEncrypted: %" PRId32, file->RCTicketEncrypted);
+	WLog_Print(log, level, "PassStub: %s", file->PassStub);
+	WLog_Print(log, level, "DtStart: %" PRIu32, file->DtStart);
+	WLog_Print(log, level, "DtLength: %" PRIu32, file->DtLength);
+	WLog_Print(log, level, "LowSpeed: %" PRId32, file->LowSpeed);
+	WLog_Print(log, level, "RASessionId: %s", file->RASessionId);
+	WLog_Print(log, level, "RASpecificParams: %s", file->RASpecificParams);
+	WLog_Print(log, level, "RASpecificParams2: %s", file->RASpecificParams2);
+
+	for (size_t x = 0; x < ArrayList_Count(file->MachineAddresses); x++)
+	{
+		UINT32 port = 0;
+		const char* uri = NULL;
+		const char* addr = ArrayList_GetItem(file->MachineAddresses, x);
+		if (x < ArrayList_Count(file->MachinePorts))
+			port = (UINT32)ArrayList_GetItem(file->MachinePorts, x);
+		if (x < ArrayList_Count(file->MachineUris))
+			uri = ArrayList_GetItem(file->MachineUris, x);
+
+		WLog_Print(log, level, "MachineAddress [%" PRIdz ": %s", x, addr);
+		WLog_Print(log, level, "MachinePort    [%" PRIdz ": %" PRIu32, x, port);
+		WLog_Print(log, level, "MachineURI     [%" PRIdz ": %s", x, uri);
+	}
+}
+
+BOOL freerdp_assistance_get_encrypted_pass_stub(rdpAssistanceFile* file, const char** pwd,
+                                                size_t* size)
+{
+	if (!file || !pwd || !size)
+		return FALSE;
+
+	*pwd = (const char*)file->EncryptedPassStub;
+	*size = file->EncryptedPassStubLength;
+	return TRUE;
+}
+
+int freerdp_assistance_set_connection_string2(rdpAssistanceFile* file, const char* string,
+                                              const char* password)
+{
+	if (!file || !string || !password)
+		return -1;
+
+	char* str = _strdup(string);
+	if (!str)
+		return -1;
+
+	if (!update_connectionstring2_nocopy(file, str))
+		return -1;
+	if (!update_password(file, password))
+		return -1;
+	return freerdp_assistance_parse_connection_string2(file);
+}
diff --git a/libfreerdp/common/settings.c b/libfreerdp/common/settings.c
new file mode 100644
index 0000000..34712c8
--- /dev/null
+++ b/libfreerdp/common/settings.c
@@ -0,0 +1,2185 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Settings Management
+ *
+ * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ * Copyright 2016 Armin Novak <armin.novak@gmail.com>
+ * Copyright 2023 Armin Novak <anovak@thincast.com>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+
+#include "../core/settings.h"
+#include "../core/capabilities.h"
+
+#include <freerdp/crypto/certificate.h>
+#include <freerdp/settings.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("common")
+
+BOOL freerdp_addin_argv_add_argument_ex(ADDIN_ARGV* args, const char* argument, size_t len)
+{
+	char* str = NULL;
+	char** new_argv = NULL;
+
+	if (!args || !argument)
+		return FALSE;
+
+	if (len == 0)
+		len = strlen(argument);
+
+	new_argv = (char**)realloc(args->argv, sizeof(char*) * (args->argc + 1));
+
+	if (!new_argv)
+		return FALSE;
+
+	args->argv = new_argv;
+
+	str = calloc(len + 1, sizeof(char));
+	if (!str)
+		return FALSE;
+	memcpy(str, argument, len);
+	args->argv[args->argc++] = str;
+	return TRUE;
+}
+
+BOOL freerdp_addin_argv_add_argument(ADDIN_ARGV* args, const char* argument)
+{
+	return freerdp_addin_argv_add_argument_ex(args, argument, 0);
+}
+
+BOOL freerdp_addin_argv_del_argument(ADDIN_ARGV* args, const char* argument)
+{
+	if (!args || !argument)
+		return FALSE;
+	for (int x = 0; x < args->argc; x++)
+	{
+		char* arg = args->argv[x];
+		if (strcmp(argument, arg) == 0)
+		{
+			free(arg);
+			memmove_s(&args->argv[x], (args->argc - x) * sizeof(char*), &args->argv[x + 1],
+			          (args->argc - x - 1) * sizeof(char*));
+			args->argv[args->argc - 1] = NULL;
+			args->argc--;
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+int freerdp_addin_set_argument(ADDIN_ARGV* args, const char* argument)
+{
+	if (!args || !argument)
+		return -2;
+
+	for (int i = 0; i < args->argc; i++)
+	{
+		if (strcmp(args->argv[i], argument) == 0)
+		{
+			return 1;
+		}
+	}
+
+	if (!freerdp_addin_argv_add_argument(args, argument))
+		return -1;
+	return 0;
+}
+
+int freerdp_addin_replace_argument(ADDIN_ARGV* args, const char* previous, const char* argument)
+{
+	if (!args || !previous || !argument)
+		return -2;
+
+	for (int i = 0; i < args->argc; i++)
+	{
+		if (strcmp(args->argv[i], previous) == 0)
+		{
+			free(args->argv[i]);
+
+			if (!(args->argv[i] = _strdup(argument)))
+				return -1;
+
+			return 1;
+		}
+	}
+
+	if (!freerdp_addin_argv_add_argument(args, argument))
+		return -1;
+	return 0;
+}
+
+int freerdp_addin_set_argument_value(ADDIN_ARGV* args, const char* option, const char* value)
+{
+	BOOL rc = 0;
+	char* p = NULL;
+	char* str = NULL;
+	size_t length = 0;
+	if (!args || !option || !value)
+		return -2;
+	length = strlen(option) + strlen(value) + 1;
+	str = (char*)calloc(length + 1, sizeof(char));
+
+	if (!str)
+		return -1;
+
+	sprintf_s(str, length + 1, "%s:%s", option, value);
+
+	for (int i = 0; i < args->argc; i++)
+	{
+		p = strchr(args->argv[i], ':');
+
+		if (p)
+		{
+			if (strncmp(args->argv[i], option, p - args->argv[i]) == 0)
+			{
+				free(args->argv[i]);
+				args->argv[i] = str;
+				return 1;
+			}
+		}
+	}
+
+	rc = freerdp_addin_argv_add_argument(args, str);
+	free(str);
+	if (!rc)
+		return -1;
+	return 0;
+}
+
+int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, const char* previous, const char* option,
+                                         const char* value)
+{
+	BOOL rc = 0;
+	char* str = NULL;
+	size_t length = 0;
+	if (!args || !previous || !option || !value)
+		return -2;
+	length = strlen(option) + strlen(value) + 1;
+	str = (char*)calloc(length + 1, sizeof(char));
+
+	if (!str)
+		return -1;
+
+	sprintf_s(str, length + 1, "%s:%s", option, value);
+
+	for (int i = 0; i < args->argc; i++)
+	{
+		if (strcmp(args->argv[i], previous) == 0)
+		{
+			free(args->argv[i]);
+			args->argv[i] = str;
+			return 1;
+		}
+	}
+
+	rc = freerdp_addin_argv_add_argument(args, str);
+	free(str);
+	if (!rc)
+		return -1;
+	return 0;
+}
+
+BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device)
+{
+	UINT32 count = 0;
+	UINT32 old = 0;
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(device);
+
+	count = freerdp_settings_get_uint32(settings, FreeRDP_DeviceCount) + 1;
+	old = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
+	if (old < count)
+	{
+		UINT32 new_size = old * 2;
+		RDPDR_DEVICE** new_array = NULL;
+
+		if (new_size == 0)
+			new_size = count * 2;
+
+		new_array =
+		    (RDPDR_DEVICE**)realloc(settings->DeviceArray, new_size * sizeof(RDPDR_DEVICE*));
+
+		if (!new_array)
+			return FALSE;
+
+		settings->DeviceArray = new_array;
+		memset(&settings->DeviceArray[old], 0, (new_size - old) * sizeof(RDPDR_DEVICE*));
+
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, new_size))
+			return FALSE;
+	}
+
+	settings->DeviceArray[settings->DeviceCount++] = device;
+	return TRUE;
+}
+
+RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings, const char* name)
+{
+	RDPDR_DEVICE* device = NULL;
+
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(name);
+	for (UINT32 index = 0; index < settings->DeviceCount; index++)
+	{
+		device = (RDPDR_DEVICE*)settings->DeviceArray[index];
+
+		if (!device->Name)
+			continue;
+
+		if (strcmp(device->Name, name) == 0)
+			return device;
+	}
+
+	return NULL;
+}
+
+RDPDR_DEVICE* freerdp_device_collection_find_type(rdpSettings* settings, UINT32 type)
+{
+	RDPDR_DEVICE* device = NULL;
+	WINPR_ASSERT(settings);
+
+	for (UINT32 index = 0; index < settings->DeviceCount; index++)
+	{
+		device = (RDPDR_DEVICE*)settings->DeviceArray[index];
+
+		if (device->Type == type)
+			return device;
+	}
+
+	return NULL;
+}
+
+RDPDR_DEVICE* freerdp_device_new(UINT32 Type, size_t count, const char* args[])
+{
+	size_t size = 0;
+	union
+	{
+		RDPDR_DEVICE* base;
+		RDPDR_DRIVE* drive;
+		RDPDR_SERIAL* serial;
+		RDPDR_PRINTER* printer;
+		RDPDR_PARALLEL* parallel;
+		RDPDR_SMARTCARD* smartcard;
+	} device;
+
+	device.base = NULL;
+	WINPR_ASSERT(args || (count == 0));
+
+	switch (Type)
+	{
+		case RDPDR_DTYP_PRINT:
+			size = sizeof(RDPDR_PRINTER);
+			break;
+		case RDPDR_DTYP_SERIAL:
+			size = sizeof(RDPDR_SERIAL);
+			break;
+		case RDPDR_DTYP_PARALLEL:
+			size = sizeof(RDPDR_PARALLEL);
+			break;
+		case RDPDR_DTYP_SMARTCARD:
+			size = sizeof(RDPDR_SMARTCARD);
+			break;
+		case RDPDR_DTYP_FILESYSTEM:
+			size = sizeof(RDPDR_DRIVE);
+			break;
+		default:
+			goto fail;
+	}
+
+	device.base = calloc(1, size);
+	if (!device.base)
+		goto fail;
+	device.base->Id = 0;
+	device.base->Type = Type;
+
+	if (count > 0)
+	{
+		device.base->Name = _strdup(args[0]);
+		if (!device.base->Name)
+			goto fail;
+
+		switch (Type)
+		{
+			case RDPDR_DTYP_PRINT:
+				if (count > 1)
+				{
+					device.printer->DriverName = _strdup(args[1]);
+					if (!device.printer->DriverName)
+						goto fail;
+				}
+
+				if (count > 2)
+				{
+					device.printer->IsDefault = _stricmp(args[2], "default") == 0;
+				}
+				break;
+			case RDPDR_DTYP_SERIAL:
+				if (count > 1)
+				{
+					device.serial->Path = _strdup(args[1]);
+					if (!device.serial->Path)
+						goto fail;
+				}
+
+				if (count > 2)
+				{
+					device.serial->Driver = _strdup(args[2]);
+					if (!device.serial->Driver)
+						goto fail;
+				}
+
+				if (count > 3)
+				{
+					device.serial->Permissive = _strdup(args[3]);
+					if (!device.serial->Permissive)
+						goto fail;
+				}
+				break;
+			case RDPDR_DTYP_PARALLEL:
+				if (count > 1)
+				{
+					device.parallel->Path = _strdup(args[1]);
+					if (!device.serial->Path)
+						goto fail;
+				}
+				break;
+			case RDPDR_DTYP_SMARTCARD:
+				break;
+			case RDPDR_DTYP_FILESYSTEM:
+				if (count > 1)
+				{
+					device.drive->Path = _strdup(args[1]);
+					if (!device.drive->Path)
+						goto fail;
+				}
+				if (count > 2)
+					device.drive->automount = (args[2] == NULL) ? TRUE : FALSE;
+				break;
+			default:
+				goto fail;
+		}
+	}
+	return device.base;
+
+fail:
+	freerdp_device_free(device.base);
+	return NULL;
+}
+
+void freerdp_device_free(RDPDR_DEVICE* device)
+{
+	union
+	{
+		RDPDR_DEVICE* dev;
+		RDPDR_DRIVE* drive;
+		RDPDR_SERIAL* serial;
+		RDPDR_PRINTER* printer;
+		RDPDR_PARALLEL* parallel;
+		RDPDR_SMARTCARD* smartcard;
+	} cnv;
+
+	cnv.dev = device;
+	if (!cnv.dev)
+		return;
+
+	switch (device->Type)
+	{
+		case RDPDR_DTYP_PRINT:
+			free(cnv.printer->DriverName);
+			break;
+		case RDPDR_DTYP_SERIAL:
+			free(cnv.serial->Path);
+			free(cnv.serial->Driver);
+			free(cnv.serial->Permissive);
+			break;
+		case RDPDR_DTYP_PARALLEL:
+			free(cnv.parallel->Path);
+			break;
+		case RDPDR_DTYP_SMARTCARD:
+			break;
+		case RDPDR_DTYP_FILESYSTEM:
+			free(cnv.drive->Path);
+			break;
+		default:
+			break;
+	}
+	free(cnv.dev->Name);
+	free(cnv.dev);
+}
+
+RDPDR_DEVICE* freerdp_device_clone(const RDPDR_DEVICE* device)
+{
+	union
+	{
+		const RDPDR_DEVICE* dev;
+		const RDPDR_DRIVE* drive;
+		const RDPDR_SERIAL* serial;
+		const RDPDR_PRINTER* printer;
+		const RDPDR_PARALLEL* parallel;
+		const RDPDR_SMARTCARD* smartcard;
+	} src;
+
+	union
+	{
+		RDPDR_DEVICE* dev;
+		RDPDR_DRIVE* drive;
+		RDPDR_SERIAL* serial;
+		RDPDR_PRINTER* printer;
+		RDPDR_PARALLEL* parallel;
+		RDPDR_SMARTCARD* smartcard;
+	} copy;
+	size_t count = 0;
+	const char* args[4] = { 0 };
+
+	copy.dev = NULL;
+	src.dev = device;
+
+	if (!device)
+		return NULL;
+
+	if (device->Name)
+	{
+		count = 1;
+		args[0] = device->Name;
+	}
+
+	switch (device->Type)
+	{
+		case RDPDR_DTYP_FILESYSTEM:
+			if (src.drive->Path)
+			{
+				args[1] = src.drive->Path;
+				count = 2;
+			}
+			break;
+
+		case RDPDR_DTYP_PRINT:
+			if (src.printer->DriverName)
+			{
+				args[1] = src.printer->DriverName;
+				count = 2;
+			}
+			break;
+
+		case RDPDR_DTYP_SMARTCARD:
+			break;
+
+		case RDPDR_DTYP_SERIAL:
+			if (src.serial->Path)
+			{
+				args[1] = src.serial->Path;
+				count = 2;
+			}
+
+			if (src.serial->Driver)
+			{
+				args[2] = src.serial->Driver;
+				count = 3;
+			}
+
+			if (src.serial->Permissive)
+			{
+				args[3] = src.serial->Permissive;
+				count = 4;
+			}
+			break;
+
+		case RDPDR_DTYP_PARALLEL:
+			if (src.parallel->Path)
+			{
+				args[1] = src.parallel->Path;
+				count = 2;
+			}
+			break;
+		default:
+			WLog_ERR(TAG, "unknown device type %" PRIu32 "", device->Type);
+			break;
+	}
+
+	copy.dev = freerdp_device_new(device->Type, count, args);
+	if (!copy.dev)
+		return NULL;
+
+	copy.dev->Id = device->Id;
+
+	return copy.dev;
+}
+
+void freerdp_device_collection_free(rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+
+	if (settings->DeviceArray)
+	{
+		for (UINT32 index = 0; index < settings->DeviceArraySize; index++)
+			freerdp_settings_set_pointer_array(settings, FreeRDP_DeviceArray, index, NULL);
+	}
+
+	free(settings->DeviceArray);
+
+	freerdp_settings_set_pointer(settings, FreeRDP_DeviceArray, NULL);
+	freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, 0);
+	freerdp_settings_set_uint32(settings, FreeRDP_DeviceCount, 0);
+}
+
+BOOL freerdp_static_channel_collection_del(rdpSettings* settings, const char* name)
+{
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
+	if (!settings || !settings->StaticChannelArray)
+		return FALSE;
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		ADDIN_ARGV* cur = settings->StaticChannelArray[x];
+		if (cur && (cur->argc > 0))
+		{
+			if (strcmp(name, cur->argv[0]) == 0)
+			{
+				const size_t rem = settings->StaticChannelArraySize - count + 1;
+				memmove_s(&settings->StaticChannelArray[x], (count - x) * sizeof(ADDIN_ARGV*),
+				          &settings->StaticChannelArray[x + 1],
+				          (count - x - 1) * sizeof(ADDIN_ARGV*));
+				memset(&settings->StaticChannelArray[count - 1], 0, sizeof(ADDIN_ARGV*) * rem);
+
+				freerdp_addin_argv_free(cur);
+				return freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, count - 1);
+			}
+		}
+	}
+	{
+		const size_t rem = settings->StaticChannelArraySize - count;
+		memset(&settings->StaticChannelArray[count], 0, sizeof(ADDIN_ARGV*) * rem);
+	}
+	return FALSE;
+}
+
+BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
+{
+	UINT32 count = 0;
+
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(channel);
+
+	count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount) + 1;
+	if (freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize) < count)
+	{
+		const UINT32 oldSize =
+		    freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
+		UINT32 new_size = oldSize * 2ul;
+		ADDIN_ARGV** new_array = NULL;
+		if (new_size == 0)
+			new_size = count * 2ul;
+
+		new_array =
+		    (ADDIN_ARGV**)realloc(settings->StaticChannelArray, new_size * sizeof(ADDIN_ARGV*));
+
+		if (!new_array)
+			return FALSE;
+
+		settings->StaticChannelArray = new_array;
+		{
+			const size_t rem = new_size - oldSize;
+			memset(&settings->StaticChannelArray[oldSize], 0, sizeof(ADDIN_ARGV*) * rem);
+		}
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, new_size))
+			return FALSE;
+	}
+
+	count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
+
+	ADDIN_ARGV** cur = &settings->StaticChannelArray[count++];
+	freerdp_addin_argv_free(*cur);
+	*cur = channel;
+	return freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, count);
+}
+
+ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const char* name)
+{
+	ADDIN_ARGV* channel = NULL;
+
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(name);
+
+	for (UINT32 index = 0;
+	     index < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount); index++)
+	{
+		channel = settings->StaticChannelArray[index];
+
+		if (strcmp(channel->argv[0], name) == 0)
+			return channel;
+	}
+
+	return NULL;
+}
+
+void freerdp_static_channel_collection_free(rdpSettings* settings)
+{
+	if (!settings)
+		return;
+
+	if (settings->StaticChannelArray)
+	{
+		for (UINT32 i = 0;
+		     i < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize); i++)
+			freerdp_addin_argv_free(settings->StaticChannelArray[i]);
+	}
+
+	free(settings->StaticChannelArray);
+	freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, 0);
+	settings->StaticChannelArray = NULL;
+	freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, 0);
+}
+
+BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings, const char* name)
+{
+	const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
+	if (!settings || !settings->DynamicChannelArray)
+		return FALSE;
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		ADDIN_ARGV* cur = settings->DynamicChannelArray[x];
+		if (cur && (cur->argc > 0))
+		{
+			if (strcmp(name, cur->argv[0]) == 0)
+			{
+				const size_t rem = settings->DynamicChannelArraySize - count + 1;
+				memmove_s(&settings->DynamicChannelArray[x], (count - x) * sizeof(ADDIN_ARGV*),
+				          &settings->DynamicChannelArray[x + 1],
+				          (count - x - 1) * sizeof(ADDIN_ARGV*));
+				memset(&settings->DynamicChannelArray[count - 1], 0, sizeof(ADDIN_ARGV*) * rem);
+
+				freerdp_addin_argv_free(cur);
+				return freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount,
+				                                   count - 1);
+			}
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
+{
+	UINT32 count = 0;
+	UINT32 oldSize = 0;
+
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(channel);
+
+	count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount) + 1;
+	oldSize = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
+	if (oldSize < count)
+	{
+		ADDIN_ARGV** new_array = NULL;
+		UINT32 size = oldSize * 2;
+		if (size == 0)
+			size = count * 2;
+
+		new_array = realloc(settings->DynamicChannelArray, sizeof(ADDIN_ARGV*) * size);
+
+		if (!new_array)
+			return FALSE;
+
+		settings->DynamicChannelArray = new_array;
+		{
+			const size_t rem = size - oldSize;
+			memset(&settings->DynamicChannelArray[oldSize], 0, sizeof(ADDIN_ARGV*) * rem);
+		}
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, size))
+			return FALSE;
+	}
+
+	count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
+	settings->DynamicChannelArray[count++] = channel;
+	return freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, count);
+}
+
+ADDIN_ARGV* freerdp_dynamic_channel_collection_find(const rdpSettings* settings, const char* name)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(name);
+
+	for (UINT32 index = 0;
+	     index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
+	{
+		ADDIN_ARGV* channel = settings->DynamicChannelArray[index];
+
+		if (strcmp(channel->argv[0], name) == 0)
+			return channel;
+	}
+
+	return NULL;
+}
+
+void freerdp_addin_argv_free(ADDIN_ARGV* args)
+{
+	if (!args)
+		return;
+
+	if (args->argv)
+	{
+		for (int index = 0; index < args->argc; index++)
+			free(args->argv[index]);
+		free(args->argv);
+	}
+
+	free(args);
+}
+
+ADDIN_ARGV* freerdp_addin_argv_new(size_t argc, const char* argv[])
+{
+	ADDIN_ARGV* args = calloc(1, sizeof(ADDIN_ARGV));
+	if (!args)
+		return NULL;
+	if (argc == 0)
+		return args;
+
+	args->argc = argc;
+	args->argv = calloc(argc, sizeof(char*));
+	if (!args->argv)
+		goto fail;
+
+	if (argv)
+	{
+		for (size_t x = 0; x < argc; x++)
+		{
+			args->argv[x] = _strdup(argv[x]);
+			if (!args->argv[x])
+				goto fail;
+		}
+	}
+	return args;
+
+fail:
+	freerdp_addin_argv_free(args);
+	return NULL;
+}
+
+ADDIN_ARGV* freerdp_addin_argv_clone(const ADDIN_ARGV* args)
+{
+	union
+	{
+		char** c;
+		const char** cc;
+	} cnv;
+	if (!args)
+		return NULL;
+	cnv.c = args->argv;
+	return freerdp_addin_argv_new(args->argc, cnv.cc);
+}
+
+void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+
+	if (settings->DynamicChannelArray)
+	{
+		for (UINT32 i = 0;
+		     i < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize); i++)
+			freerdp_addin_argv_free(settings->DynamicChannelArray[i]);
+	}
+
+	free(settings->DynamicChannelArray);
+	freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, 0);
+	settings->DynamicChannelArray = NULL;
+	freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, 0);
+}
+
+void freerdp_capability_buffer_free(rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+
+	if (settings->ReceivedCapabilityData)
+	{
+		for (UINT32 x = 0; x < settings->ReceivedCapabilitiesSize; x++)
+		{
+			free(settings->ReceivedCapabilityData[x]);
+			settings->ReceivedCapabilityData[x] = NULL;
+		}
+	}
+	settings->ReceivedCapabilitiesSize = 0;
+
+	free(settings->ReceivedCapabilityDataSizes);
+	settings->ReceivedCapabilityDataSizes = NULL;
+
+	free(settings->ReceivedCapabilityData);
+	settings->ReceivedCapabilityData = NULL;
+	free(settings->ReceivedCapabilities);
+	settings->ReceivedCapabilities = NULL;
+}
+
+BOOL freerdp_capability_buffer_copy(rdpSettings* settings, const rdpSettings* src)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(src);
+
+	if (!freerdp_capability_buffer_allocate(settings, src->ReceivedCapabilitiesSize))
+		return FALSE;
+
+	for (UINT32 x = 0; x < src->ReceivedCapabilitiesSize; x++)
+	{
+		WINPR_ASSERT(settings->ReceivedCapabilities);
+		settings->ReceivedCapabilities[x] = src->ReceivedCapabilities[x];
+
+		WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
+		settings->ReceivedCapabilityDataSizes[x] = src->ReceivedCapabilityDataSizes[x];
+
+		WINPR_ASSERT(settings->ReceivedCapabilityData);
+		if (src->ReceivedCapabilityDataSizes[x] > 0)
+		{
+			void* tmp = realloc(settings->ReceivedCapabilityData[x],
+			                    settings->ReceivedCapabilityDataSizes[x]);
+			if (!tmp)
+				return FALSE;
+			memcpy(tmp, src->ReceivedCapabilityData[x], src->ReceivedCapabilityDataSizes[x]);
+			settings->ReceivedCapabilityData[x] = tmp;
+		}
+		else
+		{
+			free(settings->ReceivedCapabilityData[x]);
+			settings->ReceivedCapabilityData[x] = NULL;
+		}
+	}
+	return TRUE;
+}
+
+void freerdp_target_net_addresses_free(rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+
+	if (settings->TargetNetAddresses)
+	{
+		for (UINT32 index = 0; index < settings->TargetNetAddressCount; index++)
+			free(settings->TargetNetAddresses[index]);
+	}
+
+	free(settings->TargetNetAddresses);
+	free(settings->TargetNetPorts);
+	settings->TargetNetAddressCount = 0;
+	settings->TargetNetAddresses = NULL;
+	settings->TargetNetPorts = NULL;
+}
+
+void freerdp_server_license_issuers_free(rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+
+	if (settings->ServerLicenseProductIssuers)
+	{
+		for (UINT32 x = 0; x < settings->ServerLicenseProductIssuersCount; x++)
+			free(settings->ServerLicenseProductIssuers[x]);
+	}
+	free(settings->ServerLicenseProductIssuers);
+	settings->ServerLicenseProductIssuers = NULL;
+	settings->ServerLicenseProductIssuersCount = 0;
+}
+
+BOOL freerdp_server_license_issuers_copy(rdpSettings* settings, char** issuers, UINT32 count)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(issuers || (count == 0));
+
+	if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerLicenseProductIssuers, NULL,
+	                                      count))
+		return FALSE;
+
+	for (UINT32 x = 0; x < count; x++)
+	{
+		char* issuer = _strdup(issuers[x]);
+		if (!issuer)
+			return FALSE;
+		settings->ServerLicenseProductIssuers[x] = issuer;
+	}
+
+	return TRUE;
+}
+
+void freerdp_performance_flags_make(rdpSettings* settings)
+{
+	UINT32 PerformanceFlags = PERF_FLAG_NONE;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_AllowFontSmoothing))
+		PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_AllowDesktopComposition))
+		PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DisableWallpaper))
+		PerformanceFlags |= PERF_DISABLE_WALLPAPER;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DisableFullWindowDrag))
+		PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DisableMenuAnims))
+		PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DisableThemes))
+		PerformanceFlags |= PERF_DISABLE_THEMING;
+	freerdp_settings_set_uint32(settings, FreeRDP_PerformanceFlags, PerformanceFlags);
+}
+
+void freerdp_performance_flags_split(rdpSettings* settings)
+{
+	freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing,
+	                          (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
+	                           PERF_ENABLE_FONT_SMOOTHING)
+	                              ? TRUE
+	                              : FALSE);
+	freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition,
+	                          (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
+	                           PERF_ENABLE_DESKTOP_COMPOSITION)
+	                              ? TRUE
+	                              : FALSE);
+	freerdp_settings_set_bool(
+	    settings, FreeRDP_DisableWallpaper,
+	    (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_WALLPAPER)
+	        ? TRUE
+	        : FALSE);
+	freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag,
+	                          (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
+	                           PERF_DISABLE_FULLWINDOWDRAG)
+	                              ? TRUE
+	                              : FALSE);
+	freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims,
+	                          (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
+	                           PERF_DISABLE_MENUANIMATIONS)
+	                              ? TRUE
+	                              : FALSE);
+	freerdp_settings_set_bool(
+	    settings, FreeRDP_DisableThemes,
+	    (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_THEMING)
+	        ? TRUE
+	        : FALSE);
+}
+
+BOOL freerdp_set_gateway_usage_method(rdpSettings* settings, UINT32 GatewayUsageMethod)
+{
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_GatewayUsageMethod, GatewayUsageMethod))
+		return FALSE;
+
+	if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
+			return FALSE;
+	}
+	else if (GatewayUsageMethod == TSC_PROXY_MODE_DIRECT)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, TRUE) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
+			return FALSE;
+	}
+	else if (GatewayUsageMethod == TSC_PROXY_MODE_DETECT)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, TRUE) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, TRUE))
+			return FALSE;
+	}
+	else if (GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT)
+	{
+		/**
+		 * This corresponds to "Automatically detect RD Gateway server settings",
+		 * which means the client attempts to use gateway group policy settings
+		 * http://technet.microsoft.com/en-us/library/cc770601.aspx
+		 */
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
+			return FALSE;
+	}
+	else if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+void freerdp_update_gateway_usage_method(rdpSettings* settings, UINT32 GatewayEnabled,
+                                         UINT32 GatewayBypassLocal)
+{
+	UINT32 GatewayUsageMethod = 0;
+
+	if (!GatewayEnabled && !GatewayBypassLocal)
+		GatewayUsageMethod = TSC_PROXY_MODE_NONE_DIRECT;
+	else if (GatewayEnabled && !GatewayBypassLocal)
+		GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
+	else if (GatewayEnabled && GatewayBypassLocal)
+		GatewayUsageMethod = TSC_PROXY_MODE_DETECT;
+
+	freerdp_set_gateway_usage_method(settings, GatewayUsageMethod);
+}
+
+#if defined(WITH_FREERDP_DEPRECATED)
+BOOL freerdp_get_param_bool(const rdpSettings* settings, int id)
+{
+	return freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)id);
+}
+
+int freerdp_set_param_bool(rdpSettings* settings, int id, BOOL param)
+{
+	return freerdp_settings_set_bool(settings, (FreeRDP_Settings_Keys_Bool)id, param) ? 0 : -1;
+}
+
+int freerdp_get_param_int(const rdpSettings* settings, int id)
+{
+	return freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)id);
+}
+
+int freerdp_set_param_int(rdpSettings* settings, int id, int param)
+{
+	return freerdp_settings_set_int32(settings, (FreeRDP_Settings_Keys_Int32)id, param) ? 0 : -1;
+}
+
+UINT32 freerdp_get_param_uint32(const rdpSettings* settings, int id)
+{
+	return freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)id);
+}
+
+int freerdp_set_param_uint32(rdpSettings* settings, int id, UINT32 param)
+{
+	return freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)id, param) ? 0 : -1;
+}
+
+UINT64 freerdp_get_param_uint64(const rdpSettings* settings, int id)
+{
+	return freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)id);
+}
+
+int freerdp_set_param_uint64(rdpSettings* settings, int id, UINT64 param)
+{
+	return freerdp_settings_set_uint64(settings, (FreeRDP_Settings_Keys_UInt64)id, param) ? 0 : -1;
+}
+
+char* freerdp_get_param_string(const rdpSettings* settings, int id)
+{
+	return (char*)freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)id);
+}
+
+int freerdp_set_param_string(rdpSettings* settings, int id, const char* param)
+{
+	return freerdp_settings_set_string(settings, (FreeRDP_Settings_Keys_String)id, param) ? 0 : -1;
+}
+#endif
+
+static BOOL value_to_uint(const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
+{
+	char* endptr = NULL;
+	unsigned long long rc = 0;
+
+	if (!value || !result)
+		return FALSE;
+
+	errno = 0;
+	rc = _strtoui64(value, &endptr, 0);
+
+	if (errno != 0)
+		return FALSE;
+
+	if (endptr == value)
+		return FALSE;
+
+	if ((rc < min) || (rc > max))
+		return FALSE;
+
+	*result = rc;
+	return TRUE;
+}
+
+static BOOL value_to_int(const char* value, LONGLONG* result, LONGLONG min, LONGLONG max)
+{
+	char* endptr = NULL;
+	long long rc = 0;
+
+	if (!value || !result)
+		return FALSE;
+
+	errno = 0;
+	rc = _strtoi64(value, &endptr, 0);
+
+	if (errno != 0)
+		return FALSE;
+
+	if (endptr == value)
+		return FALSE;
+
+	if ((rc < min) || (rc > max))
+		return FALSE;
+
+	*result = rc;
+	return TRUE;
+}
+
+static BOOL parsing_fail(const char* key, const char* type, const char* value)
+{
+	WLog_ERR(TAG, "Failed to parse key [%s] of type [%s]: value [%s]", key, type, value);
+	return FALSE;
+}
+
+BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name, const char* value)
+{
+	ULONGLONG uval = 0;
+	LONGLONG ival = 0;
+	SSIZE_T type = 0;
+
+	if (!settings || !name)
+		return FALSE;
+
+	const SSIZE_T i = freerdp_settings_get_key_for_name(name);
+	if (i < 0)
+	{
+		WLog_ERR(TAG, "Invalid settings key [%s]", name);
+		return FALSE;
+	}
+
+	const SSIZE_T index = i;
+
+	type = freerdp_settings_get_type_for_key(index);
+	switch (type)
+	{
+
+		case RDP_SETTINGS_TYPE_BOOL:
+		{
+			BOOL val = _strnicmp(value, "TRUE", 5) == 0;
+			if (!val && _strnicmp(value, "FALSE", 6) != 0)
+				return parsing_fail(name, "BOOL", value);
+			return freerdp_settings_set_bool(settings, (FreeRDP_Settings_Keys_Bool)index, val);
+		}
+		case RDP_SETTINGS_TYPE_UINT16:
+			if (!value_to_uint(value, &uval, 0, UINT16_MAX))
+				return parsing_fail(name, "UINT16", value);
+			if (!freerdp_settings_set_uint16(settings, (FreeRDP_Settings_Keys_UInt16)index, uval))
+				return parsing_fail(name, "UINT16", value);
+			return TRUE;
+
+		case RDP_SETTINGS_TYPE_INT16:
+			if (!value_to_int(value, &ival, INT16_MIN, INT16_MAX))
+				return parsing_fail(name, "INT16", value);
+			if (!freerdp_settings_set_int16(settings, (FreeRDP_Settings_Keys_Int16)index, ival))
+				return parsing_fail(name, "INT16", value);
+			return TRUE;
+		case RDP_SETTINGS_TYPE_UINT32:
+			if (!value_to_uint(value, &uval, 0, UINT32_MAX))
+				return parsing_fail(name, "UINT32", value);
+			if (!freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)index, uval))
+				return parsing_fail(name, "UINT32", value);
+			return TRUE;
+		case RDP_SETTINGS_TYPE_INT32:
+			if (!value_to_int(value, &ival, INT32_MIN, INT32_MAX))
+				return parsing_fail(name, "INT32", value);
+			if (!freerdp_settings_set_int32(settings, (FreeRDP_Settings_Keys_Int32)index, ival))
+				return parsing_fail(name, "INT32", value);
+			return TRUE;
+		case RDP_SETTINGS_TYPE_UINT64:
+			if (!value_to_uint(value, &uval, 0, UINT64_MAX))
+				return parsing_fail(name, "UINT64", value);
+			if (!freerdp_settings_set_uint64(settings, (FreeRDP_Settings_Keys_UInt64)index, uval))
+				return parsing_fail(name, "UINT64", value);
+			return TRUE;
+		case RDP_SETTINGS_TYPE_INT64:
+			if (!value_to_int(value, &ival, INT64_MIN, INT64_MAX))
+				return parsing_fail(name, "INT64", value);
+			if (!freerdp_settings_set_int64(settings, (FreeRDP_Settings_Keys_Int64)index, ival))
+				return parsing_fail(name, "INT64", value);
+			return TRUE;
+
+		case RDP_SETTINGS_TYPE_STRING:
+			return freerdp_settings_set_string(settings, (FreeRDP_Settings_Keys_String)index,
+			                                   value);
+		case RDP_SETTINGS_TYPE_POINTER:
+			return parsing_fail(name, "POINTER", value);
+		default:
+			return FALSE;
+	}
+	return FALSE;
+}
+
+BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
+                                       SSIZE_T lenId, const void* data, size_t len, size_t size)
+{
+	BOOL rc = FALSE;
+	void* copy = NULL;
+	void* old = freerdp_settings_get_pointer_writable(settings, id);
+	free(old);
+	if (!freerdp_settings_set_pointer(settings, id, NULL))
+		return FALSE;
+	if (lenId >= 0)
+	{
+		if (!freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)lenId, 0))
+			return FALSE;
+	}
+
+	if (len == 0)
+		return TRUE;
+	copy = calloc(len, size);
+	if (!copy)
+		return FALSE;
+	if (data)
+		memcpy(copy, data, len * size);
+	rc = freerdp_settings_set_pointer(settings, id, copy);
+	if (!rc)
+	{
+		free(copy);
+		return FALSE;
+	}
+
+	// freerdp_settings_set_pointer takes ownership of copy
+	//  NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
+	if (lenId < 0)
+		return TRUE;
+	return freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)lenId, len);
+}
+
+const void* freerdp_settings_get_pointer(const rdpSettings* settings,
+                                         FreeRDP_Settings_Keys_Pointer id)
+{
+	union
+	{
+		const rdpSettings* pc;
+		rdpSettings* p;
+	} cnv;
+	cnv.pc = settings;
+	return freerdp_settings_get_pointer_writable(cnv.p, id);
+}
+
+BOOL freerdp_settings_set_pointer_len(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
+                                      const void* data, size_t len)
+{
+	union
+	{
+		const void* cv;
+		void* v;
+	} cnv;
+
+	cnv.cv = data;
+	if (!settings)
+		return FALSE;
+
+	switch (id)
+	{
+		case FreeRDP_RdpServerCertificate:
+			freerdp_certificate_free(settings->RdpServerCertificate);
+
+			if (len > 1)
+			{
+				WLog_ERR(TAG, "FreeRDP_RdpServerCertificate::len must be 0 or 1");
+				return FALSE;
+			}
+			settings->RdpServerCertificate = cnv.v;
+			if (!settings->RdpServerCertificate && (len > 0))
+			{
+				settings->RdpServerCertificate = freerdp_certificate_new();
+				if (!settings->RdpServerCertificate)
+					return FALSE;
+			}
+			return TRUE;
+		case FreeRDP_RdpServerRsaKey:
+			freerdp_key_free(settings->RdpServerRsaKey);
+			if (len > 1)
+			{
+				WLog_ERR(TAG, "FreeRDP_RdpServerRsaKey::len must be 0 or 1");
+				return FALSE;
+			}
+			settings->RdpServerRsaKey = (rdpPrivateKey*)cnv.v;
+			if (!settings->RdpServerRsaKey && (len > 0))
+			{
+				settings->RdpServerRsaKey = freerdp_key_new();
+				if (!settings->RdpServerRsaKey)
+					return FALSE;
+			}
+			return TRUE;
+		case FreeRDP_RedirectionPassword:
+			return freerdp_settings_set_pointer_len_(
+			    settings, id, FreeRDP_RedirectionPasswordLength, data, len, sizeof(char));
+		case FreeRDP_RedirectionTsvUrl:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_RedirectionTsvUrlLength,
+			                                         data, len, sizeof(char));
+		case FreeRDP_RedirectionTargetCertificate:
+			freerdp_certificate_free(settings->RedirectionTargetCertificate);
+
+			if (len > 1)
+			{
+				WLog_ERR(TAG, "FreeRDP_RedirectionTargetCertificate::len must be 0 or 1");
+				return FALSE;
+			}
+			settings->RedirectionTargetCertificate = cnv.v;
+			if (!settings->RedirectionTargetCertificate && (len > 0))
+			{
+				settings->RedirectionTargetCertificate = freerdp_certificate_new();
+				if (!settings->RedirectionTargetCertificate)
+					return FALSE;
+			}
+			return TRUE;
+		case FreeRDP_RedirectionGuid:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_RedirectionGuidLength,
+			                                         data, len, sizeof(BYTE));
+		case FreeRDP_LoadBalanceInfo:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_LoadBalanceInfoLength,
+			                                         data, len, sizeof(char));
+		case FreeRDP_ServerRandom:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerRandomLength, data,
+			                                         len, sizeof(char));
+		case FreeRDP_ClientRandom:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ClientRandomLength, data,
+			                                         len, sizeof(char));
+		case FreeRDP_ServerCertificate:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerCertificateLength,
+			                                         data, len, sizeof(char));
+		case FreeRDP_TargetNetAddresses:
+			if ((data == NULL) && (len == 0))
+			{
+				freerdp_target_net_addresses_free(settings);
+				return TRUE;
+			}
+			WLog_WARN(
+			    TAG,
+			    "[BUG] FreeRDP_TargetNetAddresses must not be resized from outside the library!");
+			return FALSE;
+		case FreeRDP_ServerLicenseProductIssuers:
+			if (data == NULL)
+				freerdp_server_license_issuers_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, FreeRDP_ServerLicenseProductIssuers,
+			                                         FreeRDP_ServerLicenseProductIssuersCount, data,
+			                                         len, sizeof(char*));
+		case FreeRDP_TargetNetPorts:
+			if ((data == NULL) && (len == 0))
+			{
+				freerdp_target_net_addresses_free(settings);
+				return TRUE;
+			}
+			WLog_WARN(TAG,
+			          "[BUG] FreeRDP_TargetNetPorts must not be resized from outside the library!");
+			return FALSE;
+		case FreeRDP_DeviceArray:
+			if (data == NULL)
+				freerdp_device_collection_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_DeviceArraySize, data,
+			                                         len, sizeof(ADDIN_ARGV*));
+		case FreeRDP_ChannelDefArray:
+			if ((len > 0) && (len < CHANNEL_MAX_COUNT))
+				WLog_WARN(TAG,
+				          "FreeRDP_ChannelDefArray::len expected to be >= %" PRIu32
+				          ", but have %" PRIu32,
+				          CHANNEL_MAX_COUNT, len);
+			return freerdp_settings_set_pointer_len_(settings, FreeRDP_ChannelDefArray,
+			                                         FreeRDP_ChannelDefArraySize, data, len,
+			                                         sizeof(CHANNEL_DEF));
+		case FreeRDP_MonitorDefArray:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_MonitorDefArraySize,
+			                                         data, len, sizeof(rdpMonitor));
+		case FreeRDP_ClientAutoReconnectCookie:
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len,
+			                                         sizeof(ARC_CS_PRIVATE_PACKET));
+		case FreeRDP_ServerAutoReconnectCookie:
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len,
+			                                         sizeof(ARC_SC_PRIVATE_PACKET));
+		case FreeRDP_ClientTimeZone:
+			if (len > 1)
+			{
+				WLog_ERR(TAG, "FreeRDP_ClientTimeZone::len must be 0 or 1");
+				return FALSE;
+			}
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len,
+			                                         sizeof(TIME_ZONE_INFORMATION));
+		case FreeRDP_BitmapCacheV2CellInfo:
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_BitmapCacheV2NumCells,
+			                                         data, len, sizeof(BITMAP_CACHE_V2_CELL_INFO));
+		case FreeRDP_GlyphCache:
+			if ((len != 0) && (len != 10))
+			{
+				WLog_ERR(TAG, "FreeRDP_GlyphCache::len must be 0 or 10");
+				return FALSE;
+			}
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len,
+			                                         sizeof(GLYPH_CACHE_DEFINITION));
+		case FreeRDP_FragCache:
+			if (len > 1)
+			{
+				WLog_ERR(TAG, "FreeRDP_FragCache::len must be 0 or 1");
+				return FALSE;
+			}
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len,
+			                                         sizeof(GLYPH_CACHE_DEFINITION));
+		case FreeRDP_StaticChannelArray:
+			if (data == NULL)
+				freerdp_static_channel_collection_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_StaticChannelArraySize,
+			                                         data, len, sizeof(ADDIN_ARGV*));
+		case FreeRDP_DynamicChannelArray:
+			if (data == NULL)
+				freerdp_dynamic_channel_collection_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_DynamicChannelArraySize,
+			                                         data, len, sizeof(ADDIN_ARGV*));
+		case FreeRDP_ReceivedCapabilityData:
+			if (data == NULL)
+				freerdp_capability_buffer_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ReceivedCapabilitiesSize,
+			                                         data, len, sizeof(BYTE*));
+		case FreeRDP_ReceivedCapabilities:
+			if (data == NULL)
+				freerdp_capability_buffer_free(settings);
+			return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ReceivedCapabilitiesSize,
+			                                         data, len, sizeof(char));
+		case FreeRDP_OrderSupport:
+			return freerdp_settings_set_pointer_len_(settings, id, -1, data, len, sizeof(char));
+
+		case FreeRDP_MonitorIds:
+			return freerdp_settings_set_pointer_len_(
+			    settings, FreeRDP_MonitorIds, FreeRDP_NumMonitorIds, data, len, sizeof(UINT32));
+
+		default:
+			if ((data == NULL) && (len == 0))
+			{
+				freerdp_settings_set_pointer(settings, id, NULL);
+			}
+			else
+				WLog_WARN(TAG, "Invalid id %" PRIuz, id);
+			return FALSE;
+	}
+}
+
+void* freerdp_settings_get_pointer_array_writable(const rdpSettings* settings,
+                                                  FreeRDP_Settings_Keys_Pointer id, size_t offset)
+{
+	size_t max = 0;
+	if (!settings)
+		return NULL;
+	switch (id)
+	{
+		case FreeRDP_ClientAutoReconnectCookie:
+			max = 1;
+			if ((offset >= max) || !settings->ClientAutoReconnectCookie)
+				goto fail;
+			return &settings->ClientAutoReconnectCookie[offset];
+		case FreeRDP_ServerAutoReconnectCookie:
+			max = 1;
+			if ((offset >= max) || !settings->ServerAutoReconnectCookie)
+				goto fail;
+			return &settings->ServerAutoReconnectCookie[offset];
+		case FreeRDP_ServerCertificate:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->ServerCertificate[offset];
+		case FreeRDP_ServerRandom:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->ServerRandom[offset];
+		case FreeRDP_ClientRandom:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->ClientRandom[offset];
+		case FreeRDP_LoadBalanceInfo:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->LoadBalanceInfo[offset];
+
+		case FreeRDP_RedirectionTsvUrl:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionTsvUrlLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->RedirectionTsvUrl[offset];
+
+		case FreeRDP_RedirectionPassword:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength);
+			if (offset >= max)
+				goto fail;
+			return &settings->RedirectionPassword[offset];
+
+		case FreeRDP_OrderSupport:
+			max = 32;
+			if (offset >= max)
+				goto fail;
+			return &settings->OrderSupport[offset];
+		case FreeRDP_MonitorIds:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+			if (offset >= max)
+				goto fail;
+			return &settings->MonitorIds[offset];
+		case FreeRDP_MonitorDefArray:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
+			if (offset >= max)
+				goto fail;
+			return &settings->MonitorDefArray[offset];
+		case FreeRDP_ChannelDefArray:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
+			if (offset >= max)
+				goto fail;
+			return &settings->ChannelDefArray[offset];
+		case FreeRDP_DeviceArray:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
+			if (offset >= max)
+				goto fail;
+			return settings->DeviceArray[offset];
+		case FreeRDP_StaticChannelArray:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
+			if (offset >= max)
+				goto fail;
+			return settings->StaticChannelArray[offset];
+		case FreeRDP_DynamicChannelArray:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
+			if (offset >= max)
+				goto fail;
+			return settings->DynamicChannelArray[offset];
+		case FreeRDP_FragCache:
+			max = 1;
+			if (offset >= max)
+				goto fail;
+			return &settings->FragCache[offset];
+		case FreeRDP_GlyphCache:
+			max = 10;
+			if (offset >= max)
+				goto fail;
+			return &settings->GlyphCache[offset];
+		case FreeRDP_BitmapCacheV2CellInfo:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
+			if (offset >= max)
+				goto fail;
+			return &settings->BitmapCacheV2CellInfo[offset];
+		case FreeRDP_ReceivedCapabilities:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
+			if (offset >= max)
+				goto fail;
+			return &settings->ReceivedCapabilities[offset];
+		case FreeRDP_TargetNetAddresses:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
+			if (offset >= max)
+				goto fail;
+			return settings->TargetNetAddresses[offset];
+		case FreeRDP_TargetNetPorts:
+			max = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
+			if (offset >= max)
+				goto fail;
+			return &settings->TargetNetPorts[offset];
+		case FreeRDP_ClientTimeZone:
+			max = 1;
+			if (offset >= max)
+				goto fail;
+			return settings->ClientTimeZone;
+		case FreeRDP_RdpServerCertificate:
+			max = 1;
+			if (offset >= max)
+				goto fail;
+			return settings->RdpServerCertificate;
+		case FreeRDP_RdpServerRsaKey:
+			max = 1;
+			if (offset >= max)
+				goto fail;
+			return settings->RdpServerRsaKey;
+		default:
+			WLog_WARN(TAG, "Invalid id %s [%" PRIuz "]", freerdp_settings_get_name_for_key(id), id);
+			return NULL;
+	}
+
+fail:
+	WLog_WARN(TAG, "Invalid offset for %s [%" PRIuz "]: size=%" PRIuz ", offset=%" PRIuz,
+	          freerdp_settings_get_name_for_key(id), id, max, offset);
+	return NULL;
+}
+
+BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
+                                        size_t offset, const void* data)
+{
+	size_t maxOffset = 0;
+	if (!settings)
+		return FALSE;
+	switch (id)
+	{
+		case FreeRDP_ClientAutoReconnectCookie:
+			maxOffset = 1;
+			if ((offset >= maxOffset) || !data || !settings->ClientAutoReconnectCookie)
+				goto fail;
+			settings->ClientAutoReconnectCookie[offset] = *(const ARC_CS_PRIVATE_PACKET*)data;
+			return TRUE;
+		case FreeRDP_ServerAutoReconnectCookie:
+			maxOffset = 1;
+			if ((offset >= maxOffset) || !data || !settings->ServerAutoReconnectCookie)
+				goto fail;
+			settings->ServerAutoReconnectCookie[offset] = *(const ARC_SC_PRIVATE_PACKET*)data;
+			return TRUE;
+		case FreeRDP_ServerCertificate:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->ServerCertificate[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_DeviceArray:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
+			if (offset >= maxOffset)
+				goto fail;
+			freerdp_device_free(settings->DeviceArray[offset]);
+			settings->DeviceArray[offset] = freerdp_device_clone(data);
+			return TRUE;
+		case FreeRDP_TargetNetAddresses:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			free(settings->TargetNetAddresses[offset]);
+			settings->TargetNetAddresses[offset] = _strdup((const char*)data);
+			return settings->TargetNetAddresses[offset] != NULL;
+		case FreeRDP_TargetNetPorts:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->TargetNetPorts[offset] = *((const UINT32*)data);
+			return TRUE;
+		case FreeRDP_StaticChannelArray:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			freerdp_addin_argv_free(settings->StaticChannelArray[offset]);
+			settings->StaticChannelArray[offset] = freerdp_addin_argv_clone(data);
+			return TRUE;
+		case FreeRDP_DynamicChannelArray:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			freerdp_addin_argv_free(settings->DynamicChannelArray[offset]);
+			settings->DynamicChannelArray[offset] = freerdp_addin_argv_clone(data);
+			return TRUE;
+		case FreeRDP_BitmapCacheV2CellInfo:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			{
+				const BITMAP_CACHE_V2_CELL_INFO* cdata = (const BITMAP_CACHE_V2_CELL_INFO*)data;
+				settings->BitmapCacheV2CellInfo[offset] = *cdata;
+			}
+			return TRUE;
+		case FreeRDP_ServerRandom:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->ServerRandom[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_ClientRandom:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->ClientRandom[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_LoadBalanceInfo:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->LoadBalanceInfo[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_RedirectionTsvUrl:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionTsvUrlLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->RedirectionTsvUrl[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_RedirectionPassword:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->RedirectionPassword[offset] = *(const BYTE*)data;
+			return TRUE;
+		case FreeRDP_OrderSupport:
+			maxOffset = 32;
+			if (!settings->OrderSupport)
+				goto fail;
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->OrderSupport[offset] = *(const BOOL*)data;
+			return TRUE;
+		case FreeRDP_GlyphCache:
+			maxOffset = 10;
+			if (!settings->GlyphCache)
+				goto fail;
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->GlyphCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data;
+			return TRUE;
+		case FreeRDP_FragCache:
+			maxOffset = 1;
+			if (!settings->FragCache)
+				goto fail;
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->FragCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data;
+			return TRUE;
+		case FreeRDP_MonitorIds:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->MonitorIds[offset] = *(const UINT32*)data;
+			return TRUE;
+		case FreeRDP_ChannelDefArray:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->ChannelDefArray[offset] = *(const CHANNEL_DEF*)data;
+			return TRUE;
+		case FreeRDP_MonitorDefArray:
+			maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
+			if ((offset >= maxOffset) || !data)
+				goto fail;
+			settings->MonitorDefArray[offset] = *(const rdpMonitor*)data;
+			return TRUE;
+
+		case FreeRDP_ClientTimeZone:
+			maxOffset = 1;
+			if ((offset >= maxOffset) || !data || !settings->ClientTimeZone)
+				goto fail;
+			settings->ClientTimeZone[0] = *(const TIME_ZONE_INFORMATION*)data;
+			return TRUE;
+
+		default:
+			WLog_WARN(TAG, "Invalid id %s [%" PRIuz "]", freerdp_settings_get_name_for_key(id), id);
+			return FALSE;
+	}
+
+fail:
+	WLog_WARN(TAG, "[%s] Invalid offset=%" PRIuz " [%" PRIuz "] or NULL data=%p",
+	          freerdp_settings_get_name_for_key(id), offset, maxOffset, data);
+	return FALSE;
+}
+
+const void* freerdp_settings_get_pointer_array(const rdpSettings* settings,
+                                               FreeRDP_Settings_Keys_Pointer id, size_t offset)
+{
+	return freerdp_settings_get_pointer_array_writable(settings, id, offset);
+}
+
+UINT32 freerdp_settings_get_codecs_flags(const rdpSettings* settings)
+{
+	UINT32 flags = FREERDP_CODEC_ALL;
+	if (settings->RemoteFxCodec == FALSE)
+	{
+		flags &= ~FREERDP_CODEC_REMOTEFX;
+	}
+	if (settings->NSCodec == FALSE)
+	{
+		flags &= ~FREERDP_CODEC_NSCODEC;
+	}
+	/*TODO: check other codecs flags */
+	return flags;
+}
+
+const char* freerdp_settings_get_server_name(const rdpSettings* settings)
+{
+	WINPR_ASSERT(settings);
+	const char* hostname = settings->ServerHostname;
+
+	if (settings->UserSpecifiedServerName)
+		hostname = settings->UserSpecifiedServerName;
+
+	return hostname;
+}
+
+#if defined(WITH_FREERDP_DEPRECATED)
+ADDIN_ARGV* freerdp_static_channel_clone(ADDIN_ARGV* channel)
+{
+	return freerdp_addin_argv_clone(channel);
+}
+
+ADDIN_ARGV* freerdp_dynamic_channel_clone(ADDIN_ARGV* channel)
+{
+	return freerdp_addin_argv_clone(channel);
+}
+#endif
+
+BOOL freerdp_target_net_addresses_copy(rdpSettings* settings, char** addresses, UINT32 count)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(addresses);
+
+	if (!freerdp_target_net_adresses_reset(settings, count))
+		return FALSE;
+
+	for (UINT32 i = 0; i < settings->TargetNetAddressCount; i++)
+	{
+		if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i,
+		                                        addresses[i]))
+		{
+			freerdp_target_net_addresses_free(settings);
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
+{
+	if (!what && !expect)
+		return TRUE;
+	if (!what || !expect)
+		return FALSE;
+
+	if (what->Id != expect->Id)
+		return FALSE;
+	if (what->Type != expect->Type)
+		return FALSE;
+	if (what->Name && expect->Name)
+	{
+		if (strcmp(what->Name, expect->Name) != 0)
+			return FALSE;
+	}
+	else
+	{
+		if (what->Name != expect->Name)
+			return FALSE;
+	}
+
+	switch (what->Type)
+	{
+		case RDPDR_DTYP_PRINT:
+		{
+			const RDPDR_PRINTER* a = (const RDPDR_PRINTER*)what;
+			const RDPDR_PRINTER* b = (const RDPDR_PRINTER*)expect;
+			if (a->DriverName && b->DriverName)
+				return strcmp(a->DriverName, b->DriverName) == 0;
+			return a->DriverName == b->DriverName;
+		}
+
+		case RDPDR_DTYP_SERIAL:
+		{
+			const RDPDR_SERIAL* a = (const RDPDR_SERIAL*)what;
+			const RDPDR_SERIAL* b = (const RDPDR_SERIAL*)expect;
+
+			if (a->Path && b->Path)
+			{
+				if (strcmp(a->Path, b->Path) != 0)
+					return FALSE;
+			}
+			else if (a->Path != b->Path)
+				return FALSE;
+
+			if (a->Driver && b->Driver)
+			{
+				if (strcmp(a->Driver, b->Driver) != 0)
+					return FALSE;
+			}
+			else if (a->Driver != b->Driver)
+				return FALSE;
+			if (a->Permissive && b->Permissive)
+				return strcmp(a->Permissive, b->Permissive) == 0;
+			return a->Permissive == b->Permissive;
+		}
+
+		case RDPDR_DTYP_PARALLEL:
+		{
+			const RDPDR_PARALLEL* a = (const RDPDR_PARALLEL*)what;
+			const RDPDR_PARALLEL* b = (const RDPDR_PARALLEL*)expect;
+			if (a->Path && b->Path)
+				return strcmp(a->Path, b->Path) == 0;
+			return a->Path == b->Path;
+		}
+
+		case RDPDR_DTYP_SMARTCARD:
+			break;
+		case RDPDR_DTYP_FILESYSTEM:
+		{
+			const RDPDR_DRIVE* a = (const RDPDR_DRIVE*)what;
+			const RDPDR_DRIVE* b = (const RDPDR_DRIVE*)expect;
+			if (a->automount != b->automount)
+				return FALSE;
+			if (a->Path && b->Path)
+				return strcmp(a->Path, b->Path) == 0;
+			return a->Path == b->Path;
+		}
+
+		default:
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+char* freerdp_rail_support_flags_to_string(UINT32 flags, char* buffer, size_t length)
+{
+	const UINT32 mask =
+	    RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
+	    RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
+	    RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED |
+	    RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED;
+
+	if (flags & RAIL_LEVEL_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED", buffer, length, "|");
+	if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
+		winpr_str_append("RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length, "|");
+	if ((flags & ~mask) != 0)
+	{
+		char tbuffer[64] = { 0 };
+		_snprintf(tbuffer, sizeof(tbuffer), "RAIL_FLAG_UNKNOWN 0x%08" PRIx32, flags & mask);
+		winpr_str_append(tbuffer, buffer, length, "|");
+	}
+	return buffer;
+}
+
+BOOL freerdp_settings_update_from_caps(rdpSettings* settings, const BYTE* capsFlags,
+                                       const BYTE** capsData, const UINT32* capsSizes,
+                                       UINT32 capsCount, BOOL serverReceivedCaps)
+{
+	WINPR_ASSERT(settings);
+	WINPR_ASSERT(capsFlags || (capsCount == 0));
+	WINPR_ASSERT(capsData || (capsCount == 0));
+	WINPR_ASSERT(capsSizes || (capsCount == 0));
+	WINPR_ASSERT(capsCount <= UINT16_MAX);
+
+	for (UINT32 x = 0; x < capsCount; x++)
+	{
+		if (capsFlags[x])
+		{
+			wStream buffer;
+			wStream* sub = Stream_StaticConstInit(&buffer, capsData[x], capsSizes[x]);
+
+			if (!rdp_read_capability_set(sub, (UINT16)x, settings, serverReceivedCaps))
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+const char* freerdp_rdp_version_string(UINT32 version)
+{
+	switch (version)
+	{
+		case RDP_VERSION_4:
+			return "RDP_VERSION_4";
+		case RDP_VERSION_5_PLUS:
+			return "RDP_VERSION_5_PLUS";
+		case RDP_VERSION_10_0:
+			return "RDP_VERSION_10_0";
+		case RDP_VERSION_10_1:
+			return "RDP_VERSION_10_1";
+		case RDP_VERSION_10_2:
+			return "RDP_VERSION_10_2";
+		case RDP_VERSION_10_3:
+			return "RDP_VERSION_10_3";
+		case RDP_VERSION_10_4:
+			return "RDP_VERSION_10_4";
+		case RDP_VERSION_10_5:
+			return "RDP_VERSION_10_5";
+		case RDP_VERSION_10_6:
+			return "RDP_VERSION_10_6";
+		case RDP_VERSION_10_7:
+			return "RDP_VERSION_10_7";
+		case RDP_VERSION_10_8:
+			return "RDP_VERSION_10_8";
+		case RDP_VERSION_10_9:
+			return "RDP_VERSION_10_9";
+		case RDP_VERSION_10_10:
+			return "RDP_VERSION_10_10";
+		case RDP_VERSION_10_11:
+			return "RDP_VERSION_10_11";
+		case RDP_VERSION_10_12:
+			return "RDP_VERSION_10_12";
+		default:
+			return "RDP_VERSION_UNKNOWN";
+	}
+}
+
+BOOL freerdp_settings_set_string_from_utf16(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                            const WCHAR* param)
+{
+	WINPR_ASSERT(settings);
+
+	if (!param)
+		return freerdp_settings_set_string_copy_(settings, id, NULL, 0, TRUE);
+
+	size_t len = 0;
+
+	char* str = ConvertWCharToUtf8Alloc(param, &len);
+	if (!str && (len != 0))
+		return FALSE;
+
+	return freerdp_settings_set_string_(settings, id, str, len);
+}
+
+BOOL freerdp_settings_set_string_from_utf16N(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                             const WCHAR* param, size_t length)
+{
+	size_t len = 0;
+
+	WINPR_ASSERT(settings);
+
+	if (!param)
+		return freerdp_settings_set_string_copy_(settings, id, NULL, length, TRUE);
+
+	char* str = ConvertWCharNToUtf8Alloc(param, length, &len);
+	if (!str && (length != 0))
+	{
+		/* If the input string is an empty string, but length > 0
+		 * consider the conversion a success */
+		const size_t wlen = _wcsnlen(param, length);
+		if (wlen != 0)
+			return FALSE;
+	}
+
+	return freerdp_settings_set_string_(settings, id, str, len);
+}
+
+WCHAR* freerdp_settings_get_string_as_utf16(const rdpSettings* settings,
+                                            FreeRDP_Settings_Keys_String id, size_t* pCharLen)
+{
+	const char* str = freerdp_settings_get_string(settings, id);
+	if (pCharLen)
+		*pCharLen = 0;
+	if (!str)
+		return NULL;
+	return ConvertUtf8ToWCharAlloc(str, pCharLen);
+}
+
+const char* freerdp_rdpdr_dtyp_string(UINT32 type)
+{
+	switch (type)
+	{
+		case RDPDR_DTYP_FILESYSTEM:
+			return "RDPDR_DTYP_FILESYSTEM";
+		case RDPDR_DTYP_PARALLEL:
+			return "RDPDR_DTYP_PARALLEL";
+		case RDPDR_DTYP_PRINT:
+			return "RDPDR_DTYP_PRINT";
+		case RDPDR_DTYP_SERIAL:
+			return "RDPDR_DTYP_SERIAL";
+		case RDPDR_DTYP_SMARTCARD:
+			return "RDPDR_DTYP_SMARTCARD";
+		default:
+			return "RDPDR_DTYP_UNKNOWN";
+	}
+}
+
+const char* freerdp_encryption_level_string(UINT32 EncryptionLevel)
+{
+	switch (EncryptionLevel)
+	{
+		case ENCRYPTION_LEVEL_NONE:
+			return "ENCRYPTION_LEVEL_NONE";
+		case ENCRYPTION_LEVEL_LOW:
+			return "ENCRYPTION_LEVEL_LOW";
+		case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
+			return "ENCRYPTION_LEVEL_CLIENT_COMPATIBLE";
+		case ENCRYPTION_LEVEL_HIGH:
+			return "ENCRYPTION_LEVEL_HIGH";
+		case ENCRYPTION_LEVEL_FIPS:
+			return "ENCRYPTION_LEVEL_FIPS";
+		default:
+			return "ENCRYPTION_LEVEL_UNKNOWN";
+	}
+}
+
+const char* freerdp_encryption_methods_string(UINT32 EncryptionMethods, char* buffer, size_t size)
+{
+	if (EncryptionMethods == ENCRYPTION_METHOD_NONE)
+	{
+		winpr_str_append("ENCRYPTION_METHOD_NONE", buffer, size, "|");
+		return buffer;
+	}
+
+	if (EncryptionMethods & ENCRYPTION_METHOD_40BIT)
+	{
+		winpr_str_append("ENCRYPTION_METHOD_40BIT", buffer, size, "|");
+	}
+	if (EncryptionMethods & ENCRYPTION_METHOD_128BIT)
+	{
+		winpr_str_append("ENCRYPTION_METHOD_128BIT", buffer, size, "|");
+	}
+	if (EncryptionMethods & ENCRYPTION_METHOD_56BIT)
+	{
+		winpr_str_append("ENCRYPTION_METHOD_56BIT", buffer, size, "|");
+	}
+	if (EncryptionMethods & ENCRYPTION_METHOD_FIPS)
+	{
+		winpr_str_append("ENCRYPTION_METHOD_FIPS", buffer, size, "|");
+	}
+
+	return buffer;
+}
+
+const char* freerdp_supported_color_depths_string(UINT16 mask, char* buffer, size_t size)
+{
+	const UINT32 invalid = mask & ~(RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
+	                                RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT);
+
+	if (mask & RNS_UD_32BPP_SUPPORT)
+		winpr_str_append("RNS_UD_32BPP_SUPPORT", buffer, size, "|");
+	if (mask & RNS_UD_24BPP_SUPPORT)
+		winpr_str_append("RNS_UD_24BPP_SUPPORT", buffer, size, "|");
+	if (mask & RNS_UD_16BPP_SUPPORT)
+		winpr_str_append("RNS_UD_16BPP_SUPPORT", buffer, size, "|");
+	if (mask & RNS_UD_15BPP_SUPPORT)
+		winpr_str_append("RNS_UD_15BPP_SUPPORT", buffer, size, "|");
+
+	if (invalid != 0)
+	{
+		char str[32] = { 0 };
+		_snprintf(str, sizeof(str), "RNS_UD_INVALID[0x%04" PRIx32 "]", invalid);
+		winpr_str_append(str, buffer, size, "|");
+	}
+	char hex[32] = { 0 };
+	_snprintf(hex, sizeof(hex), "[0x%04" PRIx16 "]", mask);
+	return buffer;
+}
+
+BOOL freerdp_settings_append_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                    const char* separator, const char* param)
+{
+	const char* old = freerdp_settings_get_string(settings, id);
+
+	size_t len = 0;
+	char* str = NULL;
+
+	if (!old)
+		winpr_asprintf(&str, &len, "%s", param);
+	else if (!separator)
+		winpr_asprintf(&str, &len, "%s%s", old, param);
+	else
+		winpr_asprintf(&str, &len, "%s%s%s", old, separator, param);
+
+	const BOOL rc = freerdp_settings_set_string_len(settings, id, str, len);
+	free(str);
+	return rc;
+}
+
+BOOL freerdp_settings_are_valid(const rdpSettings* settings)
+{
+	return settings != NULL;
+}
diff --git a/libfreerdp/common/settings_getters.c b/libfreerdp/common/settings_getters.c
new file mode 100644
index 0000000..ecec044
--- /dev/null
+++ b/libfreerdp/common/settings_getters.c
@@ -0,0 +1,4153 @@
+/* Generated by  */
+
+#include "../core/settings.h"
+
+#include <winpr/assert.h>
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("common.settings")
+
+static void free_string(char** current, BOOL cleanup)
+{
+	if (cleanup)
+	{
+		if (*current)
+			memset(*current, 0, strlen(*current));
+		free(*current);
+		(*current) = NULL;
+	}
+}
+
+static BOOL alloc_empty_string(char** current, const char* next, size_t next_len)
+{
+	if (!next && (next_len > 0))
+	{
+		*current = calloc(next_len, 1);
+		return (*current != NULL);
+	}
+	return FALSE;
+}
+
+static BOOL update_string_copy_(char** current, const char* next, size_t next_len, BOOL cleanup)
+{
+	free_string(current, cleanup);
+
+	if (alloc_empty_string(current, next, next_len))
+		return TRUE;
+
+	*current = (next ? strndup(next, next_len) : NULL);
+	return !next || (*current != NULL);
+}
+
+static BOOL update_string_(char** current, char* next, size_t next_len)
+{
+	free_string(current, TRUE);
+
+	if (alloc_empty_string(current, next, next_len))
+		return TRUE;
+
+	*current = next;
+	return !next || (*current != NULL);
+}
+
+BOOL freerdp_settings_get_bool(const rdpSettings* settings, FreeRDP_Settings_Keys_Bool id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_AadSecurity:
+			return settings->AadSecurity;
+
+		case FreeRDP_AllowCacheWaitingList:
+			return settings->AllowCacheWaitingList;
+
+		case FreeRDP_AllowDesktopComposition:
+			return settings->AllowDesktopComposition;
+
+		case FreeRDP_AllowFontSmoothing:
+			return settings->AllowFontSmoothing;
+
+		case FreeRDP_AllowUnanouncedOrdersFromServer:
+			return settings->AllowUnanouncedOrdersFromServer;
+
+		case FreeRDP_AltSecFrameMarkerSupport:
+			return settings->AltSecFrameMarkerSupport;
+
+		case FreeRDP_AsyncChannels:
+			return settings->AsyncChannels;
+
+		case FreeRDP_AsyncUpdate:
+			return settings->AsyncUpdate;
+
+		case FreeRDP_AudioCapture:
+			return settings->AudioCapture;
+
+		case FreeRDP_AudioPlayback:
+			return settings->AudioPlayback;
+
+		case FreeRDP_Authentication:
+			return settings->Authentication;
+
+		case FreeRDP_AuthenticationOnly:
+			return settings->AuthenticationOnly;
+
+		case FreeRDP_AutoAcceptCertificate:
+			return settings->AutoAcceptCertificate;
+
+		case FreeRDP_AutoDenyCertificate:
+			return settings->AutoDenyCertificate;
+
+		case FreeRDP_AutoLogonEnabled:
+			return settings->AutoLogonEnabled;
+
+		case FreeRDP_AutoReconnectionEnabled:
+			return settings->AutoReconnectionEnabled;
+
+		case FreeRDP_BitmapCacheEnabled:
+			return settings->BitmapCacheEnabled;
+
+		case FreeRDP_BitmapCachePersistEnabled:
+			return settings->BitmapCachePersistEnabled;
+
+		case FreeRDP_BitmapCacheV3Enabled:
+			return settings->BitmapCacheV3Enabled;
+
+		case FreeRDP_BitmapCompressionDisabled:
+			return settings->BitmapCompressionDisabled;
+
+		case FreeRDP_CertificateCallbackPreferPEM:
+			return settings->CertificateCallbackPreferPEM;
+
+		case FreeRDP_CompressionEnabled:
+			return settings->CompressionEnabled;
+
+		case FreeRDP_ConnectChildSession:
+			return settings->ConnectChildSession;
+
+		case FreeRDP_ConsoleSession:
+			return settings->ConsoleSession;
+
+		case FreeRDP_CredentialsFromStdin:
+			return settings->CredentialsFromStdin;
+
+		case FreeRDP_DeactivateClientDecoding:
+			return settings->DeactivateClientDecoding;
+
+		case FreeRDP_Decorations:
+			return settings->Decorations;
+
+		case FreeRDP_DesktopResize:
+			return settings->DesktopResize;
+
+		case FreeRDP_DeviceRedirection:
+			return settings->DeviceRedirection;
+
+		case FreeRDP_DisableCredentialsDelegation:
+			return settings->DisableCredentialsDelegation;
+
+		case FreeRDP_DisableCtrlAltDel:
+			return settings->DisableCtrlAltDel;
+
+		case FreeRDP_DisableCursorBlinking:
+			return settings->DisableCursorBlinking;
+
+		case FreeRDP_DisableCursorShadow:
+			return settings->DisableCursorShadow;
+
+		case FreeRDP_DisableFullWindowDrag:
+			return settings->DisableFullWindowDrag;
+
+		case FreeRDP_DisableMenuAnims:
+			return settings->DisableMenuAnims;
+
+		case FreeRDP_DisableRemoteAppCapsCheck:
+			return settings->DisableRemoteAppCapsCheck;
+
+		case FreeRDP_DisableThemes:
+			return settings->DisableThemes;
+
+		case FreeRDP_DisableWallpaper:
+			return settings->DisableWallpaper;
+
+		case FreeRDP_DrawAllowColorSubsampling:
+			return settings->DrawAllowColorSubsampling;
+
+		case FreeRDP_DrawAllowDynamicColorFidelity:
+			return settings->DrawAllowDynamicColorFidelity;
+
+		case FreeRDP_DrawAllowSkipAlpha:
+			return settings->DrawAllowSkipAlpha;
+
+		case FreeRDP_DrawGdiPlusCacheEnabled:
+			return settings->DrawGdiPlusCacheEnabled;
+
+		case FreeRDP_DrawGdiPlusEnabled:
+			return settings->DrawGdiPlusEnabled;
+
+		case FreeRDP_DrawNineGridEnabled:
+			return settings->DrawNineGridEnabled;
+
+		case FreeRDP_DumpRemoteFx:
+			return settings->DumpRemoteFx;
+
+		case FreeRDP_DynamicDaylightTimeDisabled:
+			return settings->DynamicDaylightTimeDisabled;
+
+		case FreeRDP_DynamicResolutionUpdate:
+			return settings->DynamicResolutionUpdate;
+
+		case FreeRDP_EmbeddedWindow:
+			return settings->EmbeddedWindow;
+
+		case FreeRDP_EnableWindowsKey:
+			return settings->EnableWindowsKey;
+
+		case FreeRDP_EncomspVirtualChannel:
+			return settings->EncomspVirtualChannel;
+
+		case FreeRDP_ExtSecurity:
+			return settings->ExtSecurity;
+
+		case FreeRDP_ExternalCertificateManagement:
+			return settings->ExternalCertificateManagement;
+
+		case FreeRDP_FIPSMode:
+			return settings->FIPSMode;
+
+		case FreeRDP_FastPathInput:
+			return settings->FastPathInput;
+
+		case FreeRDP_FastPathOutput:
+			return settings->FastPathOutput;
+
+		case FreeRDP_ForceEncryptedCsPdu:
+			return settings->ForceEncryptedCsPdu;
+
+		case FreeRDP_ForceMultimon:
+			return settings->ForceMultimon;
+
+		case FreeRDP_FrameMarkerCommandEnabled:
+			return settings->FrameMarkerCommandEnabled;
+
+		case FreeRDP_Fullscreen:
+			return settings->Fullscreen;
+
+		case FreeRDP_GatewayArmTransport:
+			return settings->GatewayArmTransport;
+
+		case FreeRDP_GatewayBypassLocal:
+			return settings->GatewayBypassLocal;
+
+		case FreeRDP_GatewayEnabled:
+			return settings->GatewayEnabled;
+
+		case FreeRDP_GatewayHttpExtAuthSspiNtlm:
+			return settings->GatewayHttpExtAuthSspiNtlm;
+
+		case FreeRDP_GatewayHttpTransport:
+			return settings->GatewayHttpTransport;
+
+		case FreeRDP_GatewayHttpUseWebsockets:
+			return settings->GatewayHttpUseWebsockets;
+
+		case FreeRDP_GatewayRpcTransport:
+			return settings->GatewayRpcTransport;
+
+		case FreeRDP_GatewayUdpTransport:
+			return settings->GatewayUdpTransport;
+
+		case FreeRDP_GatewayUseSameCredentials:
+			return settings->GatewayUseSameCredentials;
+
+		case FreeRDP_GfxAVC444:
+			return settings->GfxAVC444;
+
+		case FreeRDP_GfxAVC444v2:
+			return settings->GfxAVC444v2;
+
+		case FreeRDP_GfxH264:
+			return settings->GfxH264;
+
+		case FreeRDP_GfxPlanar:
+			return settings->GfxPlanar;
+
+		case FreeRDP_GfxProgressive:
+			return settings->GfxProgressive;
+
+		case FreeRDP_GfxProgressiveV2:
+			return settings->GfxProgressiveV2;
+
+		case FreeRDP_GfxSendQoeAck:
+			return settings->GfxSendQoeAck;
+
+		case FreeRDP_GfxSmallCache:
+			return settings->GfxSmallCache;
+
+		case FreeRDP_GfxThinClient:
+			return settings->GfxThinClient;
+
+		case FreeRDP_GrabKeyboard:
+			return settings->GrabKeyboard;
+
+		case FreeRDP_GrabMouse:
+			return settings->GrabMouse;
+
+		case FreeRDP_HasExtendedMouseEvent:
+			return settings->HasExtendedMouseEvent;
+
+		case FreeRDP_HasHorizontalWheel:
+			return settings->HasHorizontalWheel;
+
+		case FreeRDP_HasMonitorAttributes:
+			return settings->HasMonitorAttributes;
+
+		case FreeRDP_HasQoeEvent:
+			return settings->HasQoeEvent;
+
+		case FreeRDP_HasRelativeMouseEvent:
+			return settings->HasRelativeMouseEvent;
+
+		case FreeRDP_HiDefRemoteApp:
+			return settings->HiDefRemoteApp;
+
+		case FreeRDP_IPv6Enabled:
+			return settings->IPv6Enabled;
+
+		case FreeRDP_IgnoreCertificate:
+			return settings->IgnoreCertificate;
+
+		case FreeRDP_IgnoreInvalidDevices:
+			return settings->IgnoreInvalidDevices;
+
+		case FreeRDP_JpegCodec:
+			return settings->JpegCodec;
+
+		case FreeRDP_KerberosRdgIsProxy:
+			return settings->KerberosRdgIsProxy;
+
+		case FreeRDP_ListMonitors:
+			return settings->ListMonitors;
+
+		case FreeRDP_LocalConnection:
+			return settings->LocalConnection;
+
+		case FreeRDP_LogonErrors:
+			return settings->LogonErrors;
+
+		case FreeRDP_LogonNotify:
+			return settings->LogonNotify;
+
+		case FreeRDP_LongCredentialsSupported:
+			return settings->LongCredentialsSupported;
+
+		case FreeRDP_LyncRdpMode:
+			return settings->LyncRdpMode;
+
+		case FreeRDP_MaximizeShell:
+			return settings->MaximizeShell;
+
+		case FreeRDP_MouseAttached:
+			return settings->MouseAttached;
+
+		case FreeRDP_MouseHasWheel:
+			return settings->MouseHasWheel;
+
+		case FreeRDP_MouseMotion:
+			return settings->MouseMotion;
+
+		case FreeRDP_MouseUseRelativeMove:
+			return settings->MouseUseRelativeMove;
+
+		case FreeRDP_MstscCookieMode:
+			return settings->MstscCookieMode;
+
+		case FreeRDP_MultiTouchGestures:
+			return settings->MultiTouchGestures;
+
+		case FreeRDP_MultiTouchInput:
+			return settings->MultiTouchInput;
+
+		case FreeRDP_NSCodec:
+			return settings->NSCodec;
+
+		case FreeRDP_NSCodecAllowDynamicColorFidelity:
+			return settings->NSCodecAllowDynamicColorFidelity;
+
+		case FreeRDP_NSCodecAllowSubsampling:
+			return settings->NSCodecAllowSubsampling;
+
+		case FreeRDP_NegotiateSecurityLayer:
+			return settings->NegotiateSecurityLayer;
+
+		case FreeRDP_NetworkAutoDetect:
+			return settings->NetworkAutoDetect;
+
+		case FreeRDP_NlaSecurity:
+			return settings->NlaSecurity;
+
+		case FreeRDP_NoBitmapCompressionHeader:
+			return settings->NoBitmapCompressionHeader;
+
+		case FreeRDP_OldLicenseBehaviour:
+			return settings->OldLicenseBehaviour;
+
+		case FreeRDP_PasswordIsSmartcardPin:
+			return settings->PasswordIsSmartcardPin;
+
+		case FreeRDP_PercentScreenUseHeight:
+			return settings->PercentScreenUseHeight;
+
+		case FreeRDP_PercentScreenUseWidth:
+			return settings->PercentScreenUseWidth;
+
+		case FreeRDP_PlayRemoteFx:
+			return settings->PlayRemoteFx;
+
+		case FreeRDP_PreferIPv6OverIPv4:
+			return settings->PreferIPv6OverIPv4;
+
+		case FreeRDP_PrintReconnectCookie:
+			return settings->PrintReconnectCookie;
+
+		case FreeRDP_PromptForCredentials:
+			return settings->PromptForCredentials;
+
+		case FreeRDP_RdpSecurity:
+			return settings->RdpSecurity;
+
+		case FreeRDP_RdstlsSecurity:
+			return settings->RdstlsSecurity;
+
+		case FreeRDP_RedirectClipboard:
+			return settings->RedirectClipboard;
+
+		case FreeRDP_RedirectDrives:
+			return settings->RedirectDrives;
+
+		case FreeRDP_RedirectHomeDrive:
+			return settings->RedirectHomeDrive;
+
+		case FreeRDP_RedirectParallelPorts:
+			return settings->RedirectParallelPorts;
+
+		case FreeRDP_RedirectPrinters:
+			return settings->RedirectPrinters;
+
+		case FreeRDP_RedirectSerialPorts:
+			return settings->RedirectSerialPorts;
+
+		case FreeRDP_RedirectSmartCards:
+			return settings->RedirectSmartCards;
+
+		case FreeRDP_RedirectWebAuthN:
+			return settings->RedirectWebAuthN;
+
+		case FreeRDP_RefreshRect:
+			return settings->RefreshRect;
+
+		case FreeRDP_RemdeskVirtualChannel:
+			return settings->RemdeskVirtualChannel;
+
+		case FreeRDP_RemoteAppLanguageBarSupported:
+			return settings->RemoteAppLanguageBarSupported;
+
+		case FreeRDP_RemoteApplicationMode:
+			return settings->RemoteApplicationMode;
+
+		case FreeRDP_RemoteAssistanceMode:
+			return settings->RemoteAssistanceMode;
+
+		case FreeRDP_RemoteAssistanceRequestControl:
+			return settings->RemoteAssistanceRequestControl;
+
+		case FreeRDP_RemoteConsoleAudio:
+			return settings->RemoteConsoleAudio;
+
+		case FreeRDP_RemoteCredentialGuard:
+			return settings->RemoteCredentialGuard;
+
+		case FreeRDP_RemoteFxCodec:
+			return settings->RemoteFxCodec;
+
+		case FreeRDP_RemoteFxImageCodec:
+			return settings->RemoteFxImageCodec;
+
+		case FreeRDP_RemoteFxOnly:
+			return settings->RemoteFxOnly;
+
+		case FreeRDP_RestrictedAdminModeRequired:
+			return settings->RestrictedAdminModeRequired;
+
+		case FreeRDP_SaltedChecksum:
+			return settings->SaltedChecksum;
+
+		case FreeRDP_SendPreconnectionPdu:
+			return settings->SendPreconnectionPdu;
+
+		case FreeRDP_ServerLicenseRequired:
+			return settings->ServerLicenseRequired;
+
+		case FreeRDP_ServerMode:
+			return settings->ServerMode;
+
+		case FreeRDP_SmartSizing:
+			return settings->SmartSizing;
+
+		case FreeRDP_SmartcardEmulation:
+			return settings->SmartcardEmulation;
+
+		case FreeRDP_SmartcardLogon:
+			return settings->SmartcardLogon;
+
+		case FreeRDP_SoftwareGdi:
+			return settings->SoftwareGdi;
+
+		case FreeRDP_SoundBeepsEnabled:
+			return settings->SoundBeepsEnabled;
+
+		case FreeRDP_SpanMonitors:
+			return settings->SpanMonitors;
+
+		case FreeRDP_SupportAsymetricKeys:
+			return settings->SupportAsymetricKeys;
+
+		case FreeRDP_SupportDisplayControl:
+			return settings->SupportDisplayControl;
+
+		case FreeRDP_SupportDynamicChannels:
+			return settings->SupportDynamicChannels;
+
+		case FreeRDP_SupportDynamicTimeZone:
+			return settings->SupportDynamicTimeZone;
+
+		case FreeRDP_SupportEchoChannel:
+			return settings->SupportEchoChannel;
+
+		case FreeRDP_SupportEdgeActionV1:
+			return settings->SupportEdgeActionV1;
+
+		case FreeRDP_SupportEdgeActionV2:
+			return settings->SupportEdgeActionV2;
+
+		case FreeRDP_SupportErrorInfoPdu:
+			return settings->SupportErrorInfoPdu;
+
+		case FreeRDP_SupportGeometryTracking:
+			return settings->SupportGeometryTracking;
+
+		case FreeRDP_SupportGraphicsPipeline:
+			return settings->SupportGraphicsPipeline;
+
+		case FreeRDP_SupportHeartbeatPdu:
+			return settings->SupportHeartbeatPdu;
+
+		case FreeRDP_SupportMonitorLayoutPdu:
+			return settings->SupportMonitorLayoutPdu;
+
+		case FreeRDP_SupportMultitransport:
+			return settings->SupportMultitransport;
+
+		case FreeRDP_SupportSSHAgentChannel:
+			return settings->SupportSSHAgentChannel;
+
+		case FreeRDP_SupportSkipChannelJoin:
+			return settings->SupportSkipChannelJoin;
+
+		case FreeRDP_SupportStatusInfoPdu:
+			return settings->SupportStatusInfoPdu;
+
+		case FreeRDP_SupportVideoOptimized:
+			return settings->SupportVideoOptimized;
+
+		case FreeRDP_SuppressOutput:
+			return settings->SuppressOutput;
+
+		case FreeRDP_SurfaceCommandsEnabled:
+			return settings->SurfaceCommandsEnabled;
+
+		case FreeRDP_SurfaceFrameMarkerEnabled:
+			return settings->SurfaceFrameMarkerEnabled;
+
+		case FreeRDP_SuspendInput:
+			return settings->SuspendInput;
+
+		case FreeRDP_SynchronousDynamicChannels:
+			return settings->SynchronousDynamicChannels;
+
+		case FreeRDP_SynchronousStaticChannels:
+			return settings->SynchronousStaticChannels;
+
+		case FreeRDP_TcpKeepAlive:
+			return settings->TcpKeepAlive;
+
+		case FreeRDP_TlsSecurity:
+			return settings->TlsSecurity;
+
+		case FreeRDP_ToggleFullscreen:
+			return settings->ToggleFullscreen;
+
+		case FreeRDP_TransportDump:
+			return settings->TransportDump;
+
+		case FreeRDP_TransportDumpReplay:
+			return settings->TransportDumpReplay;
+
+		case FreeRDP_UnicodeInput:
+			return settings->UnicodeInput;
+
+		case FreeRDP_UnmapButtons:
+			return settings->UnmapButtons;
+
+		case FreeRDP_UseCommonStdioCallbacks:
+			return settings->UseCommonStdioCallbacks;
+
+		case FreeRDP_UseMultimon:
+			return settings->UseMultimon;
+
+		case FreeRDP_UseRdpSecurityLayer:
+			return settings->UseRdpSecurityLayer;
+
+		case FreeRDP_UsingSavedCredentials:
+			return settings->UsingSavedCredentials;
+
+		case FreeRDP_VideoDisable:
+			return settings->VideoDisable;
+
+		case FreeRDP_VmConnectMode:
+			return settings->VmConnectMode;
+
+		case FreeRDP_WaitForOutputBufferFlush:
+			return settings->WaitForOutputBufferFlush;
+
+		case FreeRDP_Workarea:
+			return settings->Workarea;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return FALSE;
+	}
+}
+
+BOOL freerdp_settings_set_bool(rdpSettings* settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		BOOL c;
+		const BOOL cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		case FreeRDP_AadSecurity:
+			settings->AadSecurity = cnv.c;
+			break;
+
+		case FreeRDP_AllowCacheWaitingList:
+			settings->AllowCacheWaitingList = cnv.c;
+			break;
+
+		case FreeRDP_AllowDesktopComposition:
+			settings->AllowDesktopComposition = cnv.c;
+			break;
+
+		case FreeRDP_AllowFontSmoothing:
+			settings->AllowFontSmoothing = cnv.c;
+			break;
+
+		case FreeRDP_AllowUnanouncedOrdersFromServer:
+			settings->AllowUnanouncedOrdersFromServer = cnv.c;
+			break;
+
+		case FreeRDP_AltSecFrameMarkerSupport:
+			settings->AltSecFrameMarkerSupport = cnv.c;
+			break;
+
+		case FreeRDP_AsyncChannels:
+			settings->AsyncChannels = cnv.c;
+			break;
+
+		case FreeRDP_AsyncUpdate:
+			settings->AsyncUpdate = cnv.c;
+			break;
+
+		case FreeRDP_AudioCapture:
+			settings->AudioCapture = cnv.c;
+			break;
+
+		case FreeRDP_AudioPlayback:
+			settings->AudioPlayback = cnv.c;
+			break;
+
+		case FreeRDP_Authentication:
+			settings->Authentication = cnv.c;
+			break;
+
+		case FreeRDP_AuthenticationOnly:
+			settings->AuthenticationOnly = cnv.c;
+			break;
+
+		case FreeRDP_AutoAcceptCertificate:
+			settings->AutoAcceptCertificate = cnv.c;
+			break;
+
+		case FreeRDP_AutoDenyCertificate:
+			settings->AutoDenyCertificate = cnv.c;
+			break;
+
+		case FreeRDP_AutoLogonEnabled:
+			settings->AutoLogonEnabled = cnv.c;
+			break;
+
+		case FreeRDP_AutoReconnectionEnabled:
+			settings->AutoReconnectionEnabled = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCacheEnabled:
+			settings->BitmapCacheEnabled = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCachePersistEnabled:
+			settings->BitmapCachePersistEnabled = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCacheV3Enabled:
+			settings->BitmapCacheV3Enabled = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCompressionDisabled:
+			settings->BitmapCompressionDisabled = cnv.c;
+			break;
+
+		case FreeRDP_CertificateCallbackPreferPEM:
+			settings->CertificateCallbackPreferPEM = cnv.c;
+			break;
+
+		case FreeRDP_CompressionEnabled:
+			settings->CompressionEnabled = cnv.c;
+			break;
+
+		case FreeRDP_ConnectChildSession:
+			settings->ConnectChildSession = cnv.c;
+			break;
+
+		case FreeRDP_ConsoleSession:
+			settings->ConsoleSession = cnv.c;
+			break;
+
+		case FreeRDP_CredentialsFromStdin:
+			settings->CredentialsFromStdin = cnv.c;
+			break;
+
+		case FreeRDP_DeactivateClientDecoding:
+			settings->DeactivateClientDecoding = cnv.c;
+			break;
+
+		case FreeRDP_Decorations:
+			settings->Decorations = cnv.c;
+			break;
+
+		case FreeRDP_DesktopResize:
+			settings->DesktopResize = cnv.c;
+			break;
+
+		case FreeRDP_DeviceRedirection:
+			settings->DeviceRedirection = cnv.c;
+			break;
+
+		case FreeRDP_DisableCredentialsDelegation:
+			settings->DisableCredentialsDelegation = cnv.c;
+			break;
+
+		case FreeRDP_DisableCtrlAltDel:
+			settings->DisableCtrlAltDel = cnv.c;
+			break;
+
+		case FreeRDP_DisableCursorBlinking:
+			settings->DisableCursorBlinking = cnv.c;
+			break;
+
+		case FreeRDP_DisableCursorShadow:
+			settings->DisableCursorShadow = cnv.c;
+			break;
+
+		case FreeRDP_DisableFullWindowDrag:
+			settings->DisableFullWindowDrag = cnv.c;
+			break;
+
+		case FreeRDP_DisableMenuAnims:
+			settings->DisableMenuAnims = cnv.c;
+			break;
+
+		case FreeRDP_DisableRemoteAppCapsCheck:
+			settings->DisableRemoteAppCapsCheck = cnv.c;
+			break;
+
+		case FreeRDP_DisableThemes:
+			settings->DisableThemes = cnv.c;
+			break;
+
+		case FreeRDP_DisableWallpaper:
+			settings->DisableWallpaper = cnv.c;
+			break;
+
+		case FreeRDP_DrawAllowColorSubsampling:
+			settings->DrawAllowColorSubsampling = cnv.c;
+			break;
+
+		case FreeRDP_DrawAllowDynamicColorFidelity:
+			settings->DrawAllowDynamicColorFidelity = cnv.c;
+			break;
+
+		case FreeRDP_DrawAllowSkipAlpha:
+			settings->DrawAllowSkipAlpha = cnv.c;
+			break;
+
+		case FreeRDP_DrawGdiPlusCacheEnabled:
+			settings->DrawGdiPlusCacheEnabled = cnv.c;
+			break;
+
+		case FreeRDP_DrawGdiPlusEnabled:
+			settings->DrawGdiPlusEnabled = cnv.c;
+			break;
+
+		case FreeRDP_DrawNineGridEnabled:
+			settings->DrawNineGridEnabled = cnv.c;
+			break;
+
+		case FreeRDP_DumpRemoteFx:
+			settings->DumpRemoteFx = cnv.c;
+			break;
+
+		case FreeRDP_DynamicDaylightTimeDisabled:
+			settings->DynamicDaylightTimeDisabled = cnv.c;
+			break;
+
+		case FreeRDP_DynamicResolutionUpdate:
+			settings->DynamicResolutionUpdate = cnv.c;
+			break;
+
+		case FreeRDP_EmbeddedWindow:
+			settings->EmbeddedWindow = cnv.c;
+			break;
+
+		case FreeRDP_EnableWindowsKey:
+			settings->EnableWindowsKey = cnv.c;
+			break;
+
+		case FreeRDP_EncomspVirtualChannel:
+			settings->EncomspVirtualChannel = cnv.c;
+			break;
+
+		case FreeRDP_ExtSecurity:
+			settings->ExtSecurity = cnv.c;
+			break;
+
+		case FreeRDP_ExternalCertificateManagement:
+			settings->ExternalCertificateManagement = cnv.c;
+			break;
+
+		case FreeRDP_FIPSMode:
+			settings->FIPSMode = cnv.c;
+			break;
+
+		case FreeRDP_FastPathInput:
+			settings->FastPathInput = cnv.c;
+			break;
+
+		case FreeRDP_FastPathOutput:
+			settings->FastPathOutput = cnv.c;
+			break;
+
+		case FreeRDP_ForceEncryptedCsPdu:
+			settings->ForceEncryptedCsPdu = cnv.c;
+			break;
+
+		case FreeRDP_ForceMultimon:
+			settings->ForceMultimon = cnv.c;
+			break;
+
+		case FreeRDP_FrameMarkerCommandEnabled:
+			settings->FrameMarkerCommandEnabled = cnv.c;
+			break;
+
+		case FreeRDP_Fullscreen:
+			settings->Fullscreen = cnv.c;
+			break;
+
+		case FreeRDP_GatewayArmTransport:
+			settings->GatewayArmTransport = cnv.c;
+			break;
+
+		case FreeRDP_GatewayBypassLocal:
+			settings->GatewayBypassLocal = cnv.c;
+			break;
+
+		case FreeRDP_GatewayEnabled:
+			settings->GatewayEnabled = cnv.c;
+			break;
+
+		case FreeRDP_GatewayHttpExtAuthSspiNtlm:
+			settings->GatewayHttpExtAuthSspiNtlm = cnv.c;
+			break;
+
+		case FreeRDP_GatewayHttpTransport:
+			settings->GatewayHttpTransport = cnv.c;
+			break;
+
+		case FreeRDP_GatewayHttpUseWebsockets:
+			settings->GatewayHttpUseWebsockets = cnv.c;
+			break;
+
+		case FreeRDP_GatewayRpcTransport:
+			settings->GatewayRpcTransport = cnv.c;
+			break;
+
+		case FreeRDP_GatewayUdpTransport:
+			settings->GatewayUdpTransport = cnv.c;
+			break;
+
+		case FreeRDP_GatewayUseSameCredentials:
+			settings->GatewayUseSameCredentials = cnv.c;
+			break;
+
+		case FreeRDP_GfxAVC444:
+			settings->GfxAVC444 = cnv.c;
+			break;
+
+		case FreeRDP_GfxAVC444v2:
+			settings->GfxAVC444v2 = cnv.c;
+			break;
+
+		case FreeRDP_GfxH264:
+			settings->GfxH264 = cnv.c;
+			break;
+
+		case FreeRDP_GfxPlanar:
+			settings->GfxPlanar = cnv.c;
+			break;
+
+		case FreeRDP_GfxProgressive:
+			settings->GfxProgressive = cnv.c;
+			break;
+
+		case FreeRDP_GfxProgressiveV2:
+			settings->GfxProgressiveV2 = cnv.c;
+			break;
+
+		case FreeRDP_GfxSendQoeAck:
+			settings->GfxSendQoeAck = cnv.c;
+			break;
+
+		case FreeRDP_GfxSmallCache:
+			settings->GfxSmallCache = cnv.c;
+			break;
+
+		case FreeRDP_GfxThinClient:
+			settings->GfxThinClient = cnv.c;
+			break;
+
+		case FreeRDP_GrabKeyboard:
+			settings->GrabKeyboard = cnv.c;
+			break;
+
+		case FreeRDP_GrabMouse:
+			settings->GrabMouse = cnv.c;
+			break;
+
+		case FreeRDP_HasExtendedMouseEvent:
+			settings->HasExtendedMouseEvent = cnv.c;
+			break;
+
+		case FreeRDP_HasHorizontalWheel:
+			settings->HasHorizontalWheel = cnv.c;
+			break;
+
+		case FreeRDP_HasMonitorAttributes:
+			settings->HasMonitorAttributes = cnv.c;
+			break;
+
+		case FreeRDP_HasQoeEvent:
+			settings->HasQoeEvent = cnv.c;
+			break;
+
+		case FreeRDP_HasRelativeMouseEvent:
+			settings->HasRelativeMouseEvent = cnv.c;
+			break;
+
+		case FreeRDP_HiDefRemoteApp:
+			settings->HiDefRemoteApp = cnv.c;
+			break;
+
+		case FreeRDP_IPv6Enabled:
+			settings->IPv6Enabled = cnv.c;
+			break;
+
+		case FreeRDP_IgnoreCertificate:
+			settings->IgnoreCertificate = cnv.c;
+			break;
+
+		case FreeRDP_IgnoreInvalidDevices:
+			settings->IgnoreInvalidDevices = cnv.c;
+			break;
+
+		case FreeRDP_JpegCodec:
+			settings->JpegCodec = cnv.c;
+			break;
+
+		case FreeRDP_KerberosRdgIsProxy:
+			settings->KerberosRdgIsProxy = cnv.c;
+			break;
+
+		case FreeRDP_ListMonitors:
+			settings->ListMonitors = cnv.c;
+			break;
+
+		case FreeRDP_LocalConnection:
+			settings->LocalConnection = cnv.c;
+			break;
+
+		case FreeRDP_LogonErrors:
+			settings->LogonErrors = cnv.c;
+			break;
+
+		case FreeRDP_LogonNotify:
+			settings->LogonNotify = cnv.c;
+			break;
+
+		case FreeRDP_LongCredentialsSupported:
+			settings->LongCredentialsSupported = cnv.c;
+			break;
+
+		case FreeRDP_LyncRdpMode:
+			settings->LyncRdpMode = cnv.c;
+			break;
+
+		case FreeRDP_MaximizeShell:
+			settings->MaximizeShell = cnv.c;
+			break;
+
+		case FreeRDP_MouseAttached:
+			settings->MouseAttached = cnv.c;
+			break;
+
+		case FreeRDP_MouseHasWheel:
+			settings->MouseHasWheel = cnv.c;
+			break;
+
+		case FreeRDP_MouseMotion:
+			settings->MouseMotion = cnv.c;
+			break;
+
+		case FreeRDP_MouseUseRelativeMove:
+			settings->MouseUseRelativeMove = cnv.c;
+			break;
+
+		case FreeRDP_MstscCookieMode:
+			settings->MstscCookieMode = cnv.c;
+			break;
+
+		case FreeRDP_MultiTouchGestures:
+			settings->MultiTouchGestures = cnv.c;
+			break;
+
+		case FreeRDP_MultiTouchInput:
+			settings->MultiTouchInput = cnv.c;
+			break;
+
+		case FreeRDP_NSCodec:
+			settings->NSCodec = cnv.c;
+			break;
+
+		case FreeRDP_NSCodecAllowDynamicColorFidelity:
+			settings->NSCodecAllowDynamicColorFidelity = cnv.c;
+			break;
+
+		case FreeRDP_NSCodecAllowSubsampling:
+			settings->NSCodecAllowSubsampling = cnv.c;
+			break;
+
+		case FreeRDP_NegotiateSecurityLayer:
+			settings->NegotiateSecurityLayer = cnv.c;
+			break;
+
+		case FreeRDP_NetworkAutoDetect:
+			settings->NetworkAutoDetect = cnv.c;
+			break;
+
+		case FreeRDP_NlaSecurity:
+			settings->NlaSecurity = cnv.c;
+			break;
+
+		case FreeRDP_NoBitmapCompressionHeader:
+			settings->NoBitmapCompressionHeader = cnv.c;
+			break;
+
+		case FreeRDP_OldLicenseBehaviour:
+			settings->OldLicenseBehaviour = cnv.c;
+			break;
+
+		case FreeRDP_PasswordIsSmartcardPin:
+			settings->PasswordIsSmartcardPin = cnv.c;
+			break;
+
+		case FreeRDP_PercentScreenUseHeight:
+			settings->PercentScreenUseHeight = cnv.c;
+			break;
+
+		case FreeRDP_PercentScreenUseWidth:
+			settings->PercentScreenUseWidth = cnv.c;
+			break;
+
+		case FreeRDP_PlayRemoteFx:
+			settings->PlayRemoteFx = cnv.c;
+			break;
+
+		case FreeRDP_PreferIPv6OverIPv4:
+			settings->PreferIPv6OverIPv4 = cnv.c;
+			break;
+
+		case FreeRDP_PrintReconnectCookie:
+			settings->PrintReconnectCookie = cnv.c;
+			break;
+
+		case FreeRDP_PromptForCredentials:
+			settings->PromptForCredentials = cnv.c;
+			break;
+
+		case FreeRDP_RdpSecurity:
+			settings->RdpSecurity = cnv.c;
+			break;
+
+		case FreeRDP_RdstlsSecurity:
+			settings->RdstlsSecurity = cnv.c;
+			break;
+
+		case FreeRDP_RedirectClipboard:
+			settings->RedirectClipboard = cnv.c;
+			break;
+
+		case FreeRDP_RedirectDrives:
+			settings->RedirectDrives = cnv.c;
+			break;
+
+		case FreeRDP_RedirectHomeDrive:
+			settings->RedirectHomeDrive = cnv.c;
+			break;
+
+		case FreeRDP_RedirectParallelPorts:
+			settings->RedirectParallelPorts = cnv.c;
+			break;
+
+		case FreeRDP_RedirectPrinters:
+			settings->RedirectPrinters = cnv.c;
+			break;
+
+		case FreeRDP_RedirectSerialPorts:
+			settings->RedirectSerialPorts = cnv.c;
+			break;
+
+		case FreeRDP_RedirectSmartCards:
+			settings->RedirectSmartCards = cnv.c;
+			break;
+
+		case FreeRDP_RedirectWebAuthN:
+			settings->RedirectWebAuthN = cnv.c;
+			break;
+
+		case FreeRDP_RefreshRect:
+			settings->RefreshRect = cnv.c;
+			break;
+
+		case FreeRDP_RemdeskVirtualChannel:
+			settings->RemdeskVirtualChannel = cnv.c;
+			break;
+
+		case FreeRDP_RemoteAppLanguageBarSupported:
+			settings->RemoteAppLanguageBarSupported = cnv.c;
+			break;
+
+		case FreeRDP_RemoteApplicationMode:
+			settings->RemoteApplicationMode = cnv.c;
+			break;
+
+		case FreeRDP_RemoteAssistanceMode:
+			settings->RemoteAssistanceMode = cnv.c;
+			break;
+
+		case FreeRDP_RemoteAssistanceRequestControl:
+			settings->RemoteAssistanceRequestControl = cnv.c;
+			break;
+
+		case FreeRDP_RemoteConsoleAudio:
+			settings->RemoteConsoleAudio = cnv.c;
+			break;
+
+		case FreeRDP_RemoteCredentialGuard:
+			settings->RemoteCredentialGuard = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxCodec:
+			settings->RemoteFxCodec = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxImageCodec:
+			settings->RemoteFxImageCodec = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxOnly:
+			settings->RemoteFxOnly = cnv.c;
+			break;
+
+		case FreeRDP_RestrictedAdminModeRequired:
+			settings->RestrictedAdminModeRequired = cnv.c;
+			break;
+
+		case FreeRDP_SaltedChecksum:
+			settings->SaltedChecksum = cnv.c;
+			break;
+
+		case FreeRDP_SendPreconnectionPdu:
+			settings->SendPreconnectionPdu = cnv.c;
+			break;
+
+		case FreeRDP_ServerLicenseRequired:
+			settings->ServerLicenseRequired = cnv.c;
+			break;
+
+		case FreeRDP_ServerMode:
+			settings->ServerMode = cnv.c;
+			break;
+
+		case FreeRDP_SmartSizing:
+			settings->SmartSizing = cnv.c;
+			break;
+
+		case FreeRDP_SmartcardEmulation:
+			settings->SmartcardEmulation = cnv.c;
+			break;
+
+		case FreeRDP_SmartcardLogon:
+			settings->SmartcardLogon = cnv.c;
+			break;
+
+		case FreeRDP_SoftwareGdi:
+			settings->SoftwareGdi = cnv.c;
+			break;
+
+		case FreeRDP_SoundBeepsEnabled:
+			settings->SoundBeepsEnabled = cnv.c;
+			break;
+
+		case FreeRDP_SpanMonitors:
+			settings->SpanMonitors = cnv.c;
+			break;
+
+		case FreeRDP_SupportAsymetricKeys:
+			settings->SupportAsymetricKeys = cnv.c;
+			break;
+
+		case FreeRDP_SupportDisplayControl:
+			settings->SupportDisplayControl = cnv.c;
+			break;
+
+		case FreeRDP_SupportDynamicChannels:
+			settings->SupportDynamicChannels = cnv.c;
+			break;
+
+		case FreeRDP_SupportDynamicTimeZone:
+			settings->SupportDynamicTimeZone = cnv.c;
+			break;
+
+		case FreeRDP_SupportEchoChannel:
+			settings->SupportEchoChannel = cnv.c;
+			break;
+
+		case FreeRDP_SupportEdgeActionV1:
+			settings->SupportEdgeActionV1 = cnv.c;
+			break;
+
+		case FreeRDP_SupportEdgeActionV2:
+			settings->SupportEdgeActionV2 = cnv.c;
+			break;
+
+		case FreeRDP_SupportErrorInfoPdu:
+			settings->SupportErrorInfoPdu = cnv.c;
+			break;
+
+		case FreeRDP_SupportGeometryTracking:
+			settings->SupportGeometryTracking = cnv.c;
+			break;
+
+		case FreeRDP_SupportGraphicsPipeline:
+			settings->SupportGraphicsPipeline = cnv.c;
+			break;
+
+		case FreeRDP_SupportHeartbeatPdu:
+			settings->SupportHeartbeatPdu = cnv.c;
+			break;
+
+		case FreeRDP_SupportMonitorLayoutPdu:
+			settings->SupportMonitorLayoutPdu = cnv.c;
+			break;
+
+		case FreeRDP_SupportMultitransport:
+			settings->SupportMultitransport = cnv.c;
+			break;
+
+		case FreeRDP_SupportSSHAgentChannel:
+			settings->SupportSSHAgentChannel = cnv.c;
+			break;
+
+		case FreeRDP_SupportSkipChannelJoin:
+			settings->SupportSkipChannelJoin = cnv.c;
+			break;
+
+		case FreeRDP_SupportStatusInfoPdu:
+			settings->SupportStatusInfoPdu = cnv.c;
+			break;
+
+		case FreeRDP_SupportVideoOptimized:
+			settings->SupportVideoOptimized = cnv.c;
+			break;
+
+		case FreeRDP_SuppressOutput:
+			settings->SuppressOutput = cnv.c;
+			break;
+
+		case FreeRDP_SurfaceCommandsEnabled:
+			settings->SurfaceCommandsEnabled = cnv.c;
+			break;
+
+		case FreeRDP_SurfaceFrameMarkerEnabled:
+			settings->SurfaceFrameMarkerEnabled = cnv.c;
+			break;
+
+		case FreeRDP_SuspendInput:
+			settings->SuspendInput = cnv.c;
+			break;
+
+		case FreeRDP_SynchronousDynamicChannels:
+			settings->SynchronousDynamicChannels = cnv.c;
+			break;
+
+		case FreeRDP_SynchronousStaticChannels:
+			settings->SynchronousStaticChannels = cnv.c;
+			break;
+
+		case FreeRDP_TcpKeepAlive:
+			settings->TcpKeepAlive = cnv.c;
+			break;
+
+		case FreeRDP_TlsSecurity:
+			settings->TlsSecurity = cnv.c;
+			break;
+
+		case FreeRDP_ToggleFullscreen:
+			settings->ToggleFullscreen = cnv.c;
+			break;
+
+		case FreeRDP_TransportDump:
+			settings->TransportDump = cnv.c;
+			break;
+
+		case FreeRDP_TransportDumpReplay:
+			settings->TransportDumpReplay = cnv.c;
+			break;
+
+		case FreeRDP_UnicodeInput:
+			settings->UnicodeInput = cnv.c;
+			break;
+
+		case FreeRDP_UnmapButtons:
+			settings->UnmapButtons = cnv.c;
+			break;
+
+		case FreeRDP_UseCommonStdioCallbacks:
+			settings->UseCommonStdioCallbacks = cnv.c;
+			break;
+
+		case FreeRDP_UseMultimon:
+			settings->UseMultimon = cnv.c;
+			break;
+
+		case FreeRDP_UseRdpSecurityLayer:
+			settings->UseRdpSecurityLayer = cnv.c;
+			break;
+
+		case FreeRDP_UsingSavedCredentials:
+			settings->UsingSavedCredentials = cnv.c;
+			break;
+
+		case FreeRDP_VideoDisable:
+			settings->VideoDisable = cnv.c;
+			break;
+
+		case FreeRDP_VmConnectMode:
+			settings->VmConnectMode = cnv.c;
+			break;
+
+		case FreeRDP_WaitForOutputBufferFlush:
+			settings->WaitForOutputBufferFlush = cnv.c;
+			break;
+
+		case FreeRDP_Workarea:
+			settings->Workarea = cnv.c;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+UINT16 freerdp_settings_get_uint16(const rdpSettings* settings, FreeRDP_Settings_Keys_UInt16 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_CapsGeneralCompressionLevel:
+			return settings->CapsGeneralCompressionLevel;
+
+		case FreeRDP_CapsGeneralCompressionTypes:
+			return settings->CapsGeneralCompressionTypes;
+
+		case FreeRDP_CapsProtocolVersion:
+			return settings->CapsProtocolVersion;
+
+		case FreeRDP_CapsRemoteUnshareFlag:
+			return settings->CapsRemoteUnshareFlag;
+
+		case FreeRDP_CapsUpdateCapabilityFlag:
+			return settings->CapsUpdateCapabilityFlag;
+
+		case FreeRDP_DesktopOrientation:
+			return settings->DesktopOrientation;
+
+		case FreeRDP_OrderSupportFlags:
+			return settings->OrderSupportFlags;
+
+		case FreeRDP_OrderSupportFlagsEx:
+			return settings->OrderSupportFlagsEx;
+
+		case FreeRDP_ProxyPort:
+			return settings->ProxyPort;
+
+		case FreeRDP_SupportedColorDepths:
+			return settings->SupportedColorDepths;
+
+		case FreeRDP_TLSMaxVersion:
+			return settings->TLSMaxVersion;
+
+		case FreeRDP_TLSMinVersion:
+			return settings->TLSMinVersion;
+
+		case FreeRDP_TextANSICodePage:
+			return settings->TextANSICodePage;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_uint16(rdpSettings* settings, FreeRDP_Settings_Keys_UInt16 id, UINT16 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		UINT16 c;
+		const UINT16 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		case FreeRDP_CapsGeneralCompressionLevel:
+			settings->CapsGeneralCompressionLevel = cnv.c;
+			break;
+
+		case FreeRDP_CapsGeneralCompressionTypes:
+			settings->CapsGeneralCompressionTypes = cnv.c;
+			break;
+
+		case FreeRDP_CapsProtocolVersion:
+			settings->CapsProtocolVersion = cnv.c;
+			break;
+
+		case FreeRDP_CapsRemoteUnshareFlag:
+			settings->CapsRemoteUnshareFlag = cnv.c;
+			break;
+
+		case FreeRDP_CapsUpdateCapabilityFlag:
+			settings->CapsUpdateCapabilityFlag = cnv.c;
+			break;
+
+		case FreeRDP_DesktopOrientation:
+			settings->DesktopOrientation = cnv.c;
+			break;
+
+		case FreeRDP_OrderSupportFlags:
+			settings->OrderSupportFlags = cnv.c;
+			break;
+
+		case FreeRDP_OrderSupportFlagsEx:
+			settings->OrderSupportFlagsEx = cnv.c;
+			break;
+
+		case FreeRDP_ProxyPort:
+			settings->ProxyPort = cnv.c;
+			break;
+
+		case FreeRDP_SupportedColorDepths:
+			settings->SupportedColorDepths = cnv.c;
+			break;
+
+		case FreeRDP_TLSMaxVersion:
+			settings->TLSMaxVersion = cnv.c;
+			break;
+
+		case FreeRDP_TLSMinVersion:
+			settings->TLSMinVersion = cnv.c;
+			break;
+
+		case FreeRDP_TextANSICodePage:
+			settings->TextANSICodePage = cnv.c;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+INT16 freerdp_settings_get_int16(const rdpSettings* settings, FreeRDP_Settings_Keys_Int16 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_int16(rdpSettings* settings, FreeRDP_Settings_Keys_Int16 id, INT16 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		INT16 c;
+		const INT16 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, FreeRDP_Settings_Keys_UInt32 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_AcceptedCertLength:
+			return settings->AcceptedCertLength;
+
+		case FreeRDP_AuthenticationLevel:
+			return settings->AuthenticationLevel;
+
+		case FreeRDP_AutoReconnectMaxRetries:
+			return settings->AutoReconnectMaxRetries;
+
+		case FreeRDP_BitmapCacheV2NumCells:
+			return settings->BitmapCacheV2NumCells;
+
+		case FreeRDP_BitmapCacheV3CodecId:
+			return settings->BitmapCacheV3CodecId;
+
+		case FreeRDP_BitmapCacheVersion:
+			return settings->BitmapCacheVersion;
+
+		case FreeRDP_BrushSupportLevel:
+			return settings->BrushSupportLevel;
+
+		case FreeRDP_ChannelCount:
+			return settings->ChannelCount;
+
+		case FreeRDP_ChannelDefArraySize:
+			return settings->ChannelDefArraySize;
+
+		case FreeRDP_ClientBuild:
+			return settings->ClientBuild;
+
+		case FreeRDP_ClientRandomLength:
+			return settings->ClientRandomLength;
+
+		case FreeRDP_ClientSessionId:
+			return settings->ClientSessionId;
+
+		case FreeRDP_ClipboardFeatureMask:
+			return settings->ClipboardFeatureMask;
+
+		case FreeRDP_ClusterInfoFlags:
+			return settings->ClusterInfoFlags;
+
+		case FreeRDP_ColorDepth:
+			return settings->ColorDepth;
+
+		case FreeRDP_ColorPointerCacheSize:
+			return settings->ColorPointerCacheSize;
+
+		case FreeRDP_CompDeskSupportLevel:
+			return settings->CompDeskSupportLevel;
+
+		case FreeRDP_CompressionLevel:
+			return settings->CompressionLevel;
+
+		case FreeRDP_ConnectionType:
+			return settings->ConnectionType;
+
+		case FreeRDP_CookieMaxLength:
+			return settings->CookieMaxLength;
+
+		case FreeRDP_DesktopHeight:
+			return settings->DesktopHeight;
+
+		case FreeRDP_DesktopPhysicalHeight:
+			return settings->DesktopPhysicalHeight;
+
+		case FreeRDP_DesktopPhysicalWidth:
+			return settings->DesktopPhysicalWidth;
+
+		case FreeRDP_DesktopPosX:
+			return settings->DesktopPosX;
+
+		case FreeRDP_DesktopPosY:
+			return settings->DesktopPosY;
+
+		case FreeRDP_DesktopScaleFactor:
+			return settings->DesktopScaleFactor;
+
+		case FreeRDP_DesktopWidth:
+			return settings->DesktopWidth;
+
+		case FreeRDP_DeviceArraySize:
+			return settings->DeviceArraySize;
+
+		case FreeRDP_DeviceCount:
+			return settings->DeviceCount;
+
+		case FreeRDP_DeviceScaleFactor:
+			return settings->DeviceScaleFactor;
+
+		case FreeRDP_DrawNineGridCacheEntries:
+			return settings->DrawNineGridCacheEntries;
+
+		case FreeRDP_DrawNineGridCacheSize:
+			return settings->DrawNineGridCacheSize;
+
+		case FreeRDP_DynamicChannelArraySize:
+			return settings->DynamicChannelArraySize;
+
+		case FreeRDP_DynamicChannelCount:
+			return settings->DynamicChannelCount;
+
+		case FreeRDP_EarlyCapabilityFlags:
+			return settings->EarlyCapabilityFlags;
+
+		case FreeRDP_EncryptionLevel:
+			return settings->EncryptionLevel;
+
+		case FreeRDP_EncryptionMethods:
+			return settings->EncryptionMethods;
+
+		case FreeRDP_ExtEncryptionMethods:
+			return settings->ExtEncryptionMethods;
+
+		case FreeRDP_FakeMouseMotionInterval:
+			return settings->FakeMouseMotionInterval;
+
+		case FreeRDP_Floatbar:
+			return settings->Floatbar;
+
+		case FreeRDP_FrameAcknowledge:
+			return settings->FrameAcknowledge;
+
+		case FreeRDP_GatewayAcceptedCertLength:
+			return settings->GatewayAcceptedCertLength;
+
+		case FreeRDP_GatewayCredentialsSource:
+			return settings->GatewayCredentialsSource;
+
+		case FreeRDP_GatewayPort:
+			return settings->GatewayPort;
+
+		case FreeRDP_GatewayUsageMethod:
+			return settings->GatewayUsageMethod;
+
+		case FreeRDP_GfxCapsFilter:
+			return settings->GfxCapsFilter;
+
+		case FreeRDP_GlyphSupportLevel:
+			return settings->GlyphSupportLevel;
+
+		case FreeRDP_JpegCodecId:
+			return settings->JpegCodecId;
+
+		case FreeRDP_JpegQuality:
+			return settings->JpegQuality;
+
+		case FreeRDP_KeySpec:
+			return settings->KeySpec;
+
+		case FreeRDP_KeyboardCodePage:
+			return settings->KeyboardCodePage;
+
+		case FreeRDP_KeyboardFunctionKey:
+			return settings->KeyboardFunctionKey;
+
+		case FreeRDP_KeyboardHook:
+			return settings->KeyboardHook;
+
+		case FreeRDP_KeyboardLayout:
+			return settings->KeyboardLayout;
+
+		case FreeRDP_KeyboardSubType:
+			return settings->KeyboardSubType;
+
+		case FreeRDP_KeyboardType:
+			return settings->KeyboardType;
+
+		case FreeRDP_LargePointerFlag:
+			return settings->LargePointerFlag;
+
+		case FreeRDP_LoadBalanceInfoLength:
+			return settings->LoadBalanceInfoLength;
+
+		case FreeRDP_MonitorAttributeFlags:
+			return settings->MonitorAttributeFlags;
+
+		case FreeRDP_MonitorCount:
+			return settings->MonitorCount;
+
+		case FreeRDP_MonitorDefArraySize:
+			return settings->MonitorDefArraySize;
+
+		case FreeRDP_MonitorFlags:
+			return settings->MonitorFlags;
+
+		case FreeRDP_MonitorLocalShiftX:
+			return settings->MonitorLocalShiftX;
+
+		case FreeRDP_MonitorLocalShiftY:
+			return settings->MonitorLocalShiftY;
+
+		case FreeRDP_MultifragMaxRequestSize:
+			return settings->MultifragMaxRequestSize;
+
+		case FreeRDP_MultitransportFlags:
+			return settings->MultitransportFlags;
+
+		case FreeRDP_NSCodecColorLossLevel:
+			return settings->NSCodecColorLossLevel;
+
+		case FreeRDP_NSCodecId:
+			return settings->NSCodecId;
+
+		case FreeRDP_NegotiationFlags:
+			return settings->NegotiationFlags;
+
+		case FreeRDP_NumMonitorIds:
+			return settings->NumMonitorIds;
+
+		case FreeRDP_OffscreenCacheEntries:
+			return settings->OffscreenCacheEntries;
+
+		case FreeRDP_OffscreenCacheSize:
+			return settings->OffscreenCacheSize;
+
+		case FreeRDP_OffscreenSupportLevel:
+			return settings->OffscreenSupportLevel;
+
+		case FreeRDP_OsMajorType:
+			return settings->OsMajorType;
+
+		case FreeRDP_OsMinorType:
+			return settings->OsMinorType;
+
+		case FreeRDP_Password51Length:
+			return settings->Password51Length;
+
+		case FreeRDP_PduSource:
+			return settings->PduSource;
+
+		case FreeRDP_PercentScreen:
+			return settings->PercentScreen;
+
+		case FreeRDP_PerformanceFlags:
+			return settings->PerformanceFlags;
+
+		case FreeRDP_PointerCacheSize:
+			return settings->PointerCacheSize;
+
+		case FreeRDP_PreconnectionId:
+			return settings->PreconnectionId;
+
+		case FreeRDP_ProxyType:
+			return settings->ProxyType;
+
+		case FreeRDP_RdpVersion:
+			return settings->RdpVersion;
+
+		case FreeRDP_ReceivedCapabilitiesSize:
+			return settings->ReceivedCapabilitiesSize;
+
+		case FreeRDP_RedirectedSessionId:
+			return settings->RedirectedSessionId;
+
+		case FreeRDP_RedirectionAcceptedCertLength:
+			return settings->RedirectionAcceptedCertLength;
+
+		case FreeRDP_RedirectionFlags:
+			return settings->RedirectionFlags;
+
+		case FreeRDP_RedirectionGuidLength:
+			return settings->RedirectionGuidLength;
+
+		case FreeRDP_RedirectionPasswordLength:
+			return settings->RedirectionPasswordLength;
+
+		case FreeRDP_RedirectionPreferType:
+			return settings->RedirectionPreferType;
+
+		case FreeRDP_RedirectionTsvUrlLength:
+			return settings->RedirectionTsvUrlLength;
+
+		case FreeRDP_RemoteAppNumIconCacheEntries:
+			return settings->RemoteAppNumIconCacheEntries;
+
+		case FreeRDP_RemoteAppNumIconCaches:
+			return settings->RemoteAppNumIconCaches;
+
+		case FreeRDP_RemoteApplicationExpandCmdLine:
+			return settings->RemoteApplicationExpandCmdLine;
+
+		case FreeRDP_RemoteApplicationExpandWorkingDir:
+			return settings->RemoteApplicationExpandWorkingDir;
+
+		case FreeRDP_RemoteApplicationSupportLevel:
+			return settings->RemoteApplicationSupportLevel;
+
+		case FreeRDP_RemoteApplicationSupportMask:
+			return settings->RemoteApplicationSupportMask;
+
+		case FreeRDP_RemoteFxCaptureFlags:
+			return settings->RemoteFxCaptureFlags;
+
+		case FreeRDP_RemoteFxCodecId:
+			return settings->RemoteFxCodecId;
+
+		case FreeRDP_RemoteFxCodecMode:
+			return settings->RemoteFxCodecMode;
+
+		case FreeRDP_RemoteWndSupportLevel:
+			return settings->RemoteWndSupportLevel;
+
+		case FreeRDP_RequestedProtocols:
+			return settings->RequestedProtocols;
+
+		case FreeRDP_SelectedProtocol:
+			return settings->SelectedProtocol;
+
+		case FreeRDP_ServerCertificateLength:
+			return settings->ServerCertificateLength;
+
+		case FreeRDP_ServerLicenseProductIssuersCount:
+			return settings->ServerLicenseProductIssuersCount;
+
+		case FreeRDP_ServerLicenseProductVersion:
+			return settings->ServerLicenseProductVersion;
+
+		case FreeRDP_ServerPort:
+			return settings->ServerPort;
+
+		case FreeRDP_ServerRandomLength:
+			return settings->ServerRandomLength;
+
+		case FreeRDP_ShareId:
+			return settings->ShareId;
+
+		case FreeRDP_SmartSizingHeight:
+			return settings->SmartSizingHeight;
+
+		case FreeRDP_SmartSizingWidth:
+			return settings->SmartSizingWidth;
+
+		case FreeRDP_StaticChannelArraySize:
+			return settings->StaticChannelArraySize;
+
+		case FreeRDP_StaticChannelCount:
+			return settings->StaticChannelCount;
+
+		case FreeRDP_TargetNetAddressCount:
+			return settings->TargetNetAddressCount;
+
+		case FreeRDP_TcpAckTimeout:
+			return settings->TcpAckTimeout;
+
+		case FreeRDP_TcpConnectTimeout:
+			return settings->TcpConnectTimeout;
+
+		case FreeRDP_TcpKeepAliveDelay:
+			return settings->TcpKeepAliveDelay;
+
+		case FreeRDP_TcpKeepAliveInterval:
+			return settings->TcpKeepAliveInterval;
+
+		case FreeRDP_TcpKeepAliveRetries:
+			return settings->TcpKeepAliveRetries;
+
+		case FreeRDP_ThreadingFlags:
+			return settings->ThreadingFlags;
+
+		case FreeRDP_TlsSecLevel:
+			return settings->TlsSecLevel;
+
+		case FreeRDP_VCChunkSize:
+			return settings->VCChunkSize;
+
+		case FreeRDP_VCFlags:
+			return settings->VCFlags;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_uint32(rdpSettings* settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		UINT32 c;
+		const UINT32 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		case FreeRDP_AcceptedCertLength:
+			settings->AcceptedCertLength = cnv.c;
+			break;
+
+		case FreeRDP_AuthenticationLevel:
+			settings->AuthenticationLevel = cnv.c;
+			break;
+
+		case FreeRDP_AutoReconnectMaxRetries:
+			settings->AutoReconnectMaxRetries = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCacheV2NumCells:
+			settings->BitmapCacheV2NumCells = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCacheV3CodecId:
+			settings->BitmapCacheV3CodecId = cnv.c;
+			break;
+
+		case FreeRDP_BitmapCacheVersion:
+			settings->BitmapCacheVersion = cnv.c;
+			break;
+
+		case FreeRDP_BrushSupportLevel:
+			settings->BrushSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_ChannelCount:
+			settings->ChannelCount = cnv.c;
+			break;
+
+		case FreeRDP_ChannelDefArraySize:
+			settings->ChannelDefArraySize = cnv.c;
+			break;
+
+		case FreeRDP_ClientBuild:
+			settings->ClientBuild = cnv.c;
+			break;
+
+		case FreeRDP_ClientRandomLength:
+			settings->ClientRandomLength = cnv.c;
+			break;
+
+		case FreeRDP_ClientSessionId:
+			settings->ClientSessionId = cnv.c;
+			break;
+
+		case FreeRDP_ClipboardFeatureMask:
+			settings->ClipboardFeatureMask = cnv.c;
+			break;
+
+		case FreeRDP_ClusterInfoFlags:
+			settings->ClusterInfoFlags = cnv.c;
+			break;
+
+		case FreeRDP_ColorDepth:
+			settings->ColorDepth = cnv.c;
+			break;
+
+		case FreeRDP_ColorPointerCacheSize:
+			settings->ColorPointerCacheSize = cnv.c;
+			break;
+
+		case FreeRDP_CompDeskSupportLevel:
+			settings->CompDeskSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_CompressionLevel:
+			settings->CompressionLevel = cnv.c;
+			break;
+
+		case FreeRDP_ConnectionType:
+			settings->ConnectionType = cnv.c;
+			break;
+
+		case FreeRDP_CookieMaxLength:
+			settings->CookieMaxLength = cnv.c;
+			break;
+
+		case FreeRDP_DesktopHeight:
+			settings->DesktopHeight = cnv.c;
+			break;
+
+		case FreeRDP_DesktopPhysicalHeight:
+			settings->DesktopPhysicalHeight = cnv.c;
+			break;
+
+		case FreeRDP_DesktopPhysicalWidth:
+			settings->DesktopPhysicalWidth = cnv.c;
+			break;
+
+		case FreeRDP_DesktopPosX:
+			settings->DesktopPosX = cnv.c;
+			break;
+
+		case FreeRDP_DesktopPosY:
+			settings->DesktopPosY = cnv.c;
+			break;
+
+		case FreeRDP_DesktopScaleFactor:
+			settings->DesktopScaleFactor = cnv.c;
+			break;
+
+		case FreeRDP_DesktopWidth:
+			settings->DesktopWidth = cnv.c;
+			break;
+
+		case FreeRDP_DeviceArraySize:
+			settings->DeviceArraySize = cnv.c;
+			break;
+
+		case FreeRDP_DeviceCount:
+			settings->DeviceCount = cnv.c;
+			break;
+
+		case FreeRDP_DeviceScaleFactor:
+			settings->DeviceScaleFactor = cnv.c;
+			break;
+
+		case FreeRDP_DrawNineGridCacheEntries:
+			settings->DrawNineGridCacheEntries = cnv.c;
+			break;
+
+		case FreeRDP_DrawNineGridCacheSize:
+			settings->DrawNineGridCacheSize = cnv.c;
+			break;
+
+		case FreeRDP_DynamicChannelArraySize:
+			settings->DynamicChannelArraySize = cnv.c;
+			break;
+
+		case FreeRDP_DynamicChannelCount:
+			settings->DynamicChannelCount = cnv.c;
+			break;
+
+		case FreeRDP_EarlyCapabilityFlags:
+			settings->EarlyCapabilityFlags = cnv.c;
+			break;
+
+		case FreeRDP_EncryptionLevel:
+			settings->EncryptionLevel = cnv.c;
+			break;
+
+		case FreeRDP_EncryptionMethods:
+			settings->EncryptionMethods = cnv.c;
+			break;
+
+		case FreeRDP_ExtEncryptionMethods:
+			settings->ExtEncryptionMethods = cnv.c;
+			break;
+
+		case FreeRDP_FakeMouseMotionInterval:
+			settings->FakeMouseMotionInterval = cnv.c;
+			break;
+
+		case FreeRDP_Floatbar:
+			settings->Floatbar = cnv.c;
+			break;
+
+		case FreeRDP_FrameAcknowledge:
+			settings->FrameAcknowledge = cnv.c;
+			break;
+
+		case FreeRDP_GatewayAcceptedCertLength:
+			settings->GatewayAcceptedCertLength = cnv.c;
+			break;
+
+		case FreeRDP_GatewayCredentialsSource:
+			settings->GatewayCredentialsSource = cnv.c;
+			break;
+
+		case FreeRDP_GatewayPort:
+			settings->GatewayPort = cnv.c;
+			break;
+
+		case FreeRDP_GatewayUsageMethod:
+			settings->GatewayUsageMethod = cnv.c;
+			break;
+
+		case FreeRDP_GfxCapsFilter:
+			settings->GfxCapsFilter = cnv.c;
+			break;
+
+		case FreeRDP_GlyphSupportLevel:
+			settings->GlyphSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_JpegCodecId:
+			settings->JpegCodecId = cnv.c;
+			break;
+
+		case FreeRDP_JpegQuality:
+			settings->JpegQuality = cnv.c;
+			break;
+
+		case FreeRDP_KeySpec:
+			settings->KeySpec = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardCodePage:
+			settings->KeyboardCodePage = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardFunctionKey:
+			settings->KeyboardFunctionKey = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardHook:
+			settings->KeyboardHook = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardLayout:
+			settings->KeyboardLayout = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardSubType:
+			settings->KeyboardSubType = cnv.c;
+			break;
+
+		case FreeRDP_KeyboardType:
+			settings->KeyboardType = cnv.c;
+			break;
+
+		case FreeRDP_LargePointerFlag:
+			settings->LargePointerFlag = cnv.c;
+			break;
+
+		case FreeRDP_LoadBalanceInfoLength:
+			settings->LoadBalanceInfoLength = cnv.c;
+			break;
+
+		case FreeRDP_MonitorAttributeFlags:
+			settings->MonitorAttributeFlags = cnv.c;
+			break;
+
+		case FreeRDP_MonitorCount:
+			settings->MonitorCount = cnv.c;
+			break;
+
+		case FreeRDP_MonitorDefArraySize:
+			settings->MonitorDefArraySize = cnv.c;
+			break;
+
+		case FreeRDP_MonitorFlags:
+			settings->MonitorFlags = cnv.c;
+			break;
+
+		case FreeRDP_MonitorLocalShiftX:
+			settings->MonitorLocalShiftX = cnv.c;
+			break;
+
+		case FreeRDP_MonitorLocalShiftY:
+			settings->MonitorLocalShiftY = cnv.c;
+			break;
+
+		case FreeRDP_MultifragMaxRequestSize:
+			settings->MultifragMaxRequestSize = cnv.c;
+			break;
+
+		case FreeRDP_MultitransportFlags:
+			settings->MultitransportFlags = cnv.c;
+			break;
+
+		case FreeRDP_NSCodecColorLossLevel:
+			settings->NSCodecColorLossLevel = cnv.c;
+			break;
+
+		case FreeRDP_NSCodecId:
+			settings->NSCodecId = cnv.c;
+			break;
+
+		case FreeRDP_NegotiationFlags:
+			settings->NegotiationFlags = cnv.c;
+			break;
+
+		case FreeRDP_NumMonitorIds:
+			settings->NumMonitorIds = cnv.c;
+			break;
+
+		case FreeRDP_OffscreenCacheEntries:
+			settings->OffscreenCacheEntries = cnv.c;
+			break;
+
+		case FreeRDP_OffscreenCacheSize:
+			settings->OffscreenCacheSize = cnv.c;
+			break;
+
+		case FreeRDP_OffscreenSupportLevel:
+			settings->OffscreenSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_OsMajorType:
+			settings->OsMajorType = cnv.c;
+			break;
+
+		case FreeRDP_OsMinorType:
+			settings->OsMinorType = cnv.c;
+			break;
+
+		case FreeRDP_Password51Length:
+			settings->Password51Length = cnv.c;
+			break;
+
+		case FreeRDP_PduSource:
+			settings->PduSource = cnv.c;
+			break;
+
+		case FreeRDP_PercentScreen:
+			settings->PercentScreen = cnv.c;
+			break;
+
+		case FreeRDP_PerformanceFlags:
+			settings->PerformanceFlags = cnv.c;
+			break;
+
+		case FreeRDP_PointerCacheSize:
+			settings->PointerCacheSize = cnv.c;
+			break;
+
+		case FreeRDP_PreconnectionId:
+			settings->PreconnectionId = cnv.c;
+			break;
+
+		case FreeRDP_ProxyType:
+			settings->ProxyType = cnv.c;
+			break;
+
+		case FreeRDP_RdpVersion:
+			settings->RdpVersion = cnv.c;
+			break;
+
+		case FreeRDP_ReceivedCapabilitiesSize:
+			settings->ReceivedCapabilitiesSize = cnv.c;
+			break;
+
+		case FreeRDP_RedirectedSessionId:
+			settings->RedirectedSessionId = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionAcceptedCertLength:
+			settings->RedirectionAcceptedCertLength = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionFlags:
+			settings->RedirectionFlags = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionGuidLength:
+			settings->RedirectionGuidLength = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionPasswordLength:
+			settings->RedirectionPasswordLength = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionPreferType:
+			settings->RedirectionPreferType = cnv.c;
+			break;
+
+		case FreeRDP_RedirectionTsvUrlLength:
+			settings->RedirectionTsvUrlLength = cnv.c;
+			break;
+
+		case FreeRDP_RemoteAppNumIconCacheEntries:
+			settings->RemoteAppNumIconCacheEntries = cnv.c;
+			break;
+
+		case FreeRDP_RemoteAppNumIconCaches:
+			settings->RemoteAppNumIconCaches = cnv.c;
+			break;
+
+		case FreeRDP_RemoteApplicationExpandCmdLine:
+			settings->RemoteApplicationExpandCmdLine = cnv.c;
+			break;
+
+		case FreeRDP_RemoteApplicationExpandWorkingDir:
+			settings->RemoteApplicationExpandWorkingDir = cnv.c;
+			break;
+
+		case FreeRDP_RemoteApplicationSupportLevel:
+			settings->RemoteApplicationSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_RemoteApplicationSupportMask:
+			settings->RemoteApplicationSupportMask = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxCaptureFlags:
+			settings->RemoteFxCaptureFlags = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxCodecId:
+			settings->RemoteFxCodecId = cnv.c;
+			break;
+
+		case FreeRDP_RemoteFxCodecMode:
+			settings->RemoteFxCodecMode = cnv.c;
+			break;
+
+		case FreeRDP_RemoteWndSupportLevel:
+			settings->RemoteWndSupportLevel = cnv.c;
+			break;
+
+		case FreeRDP_RequestedProtocols:
+			settings->RequestedProtocols = cnv.c;
+			break;
+
+		case FreeRDP_SelectedProtocol:
+			settings->SelectedProtocol = cnv.c;
+			break;
+
+		case FreeRDP_ServerCertificateLength:
+			settings->ServerCertificateLength = cnv.c;
+			break;
+
+		case FreeRDP_ServerLicenseProductIssuersCount:
+			settings->ServerLicenseProductIssuersCount = cnv.c;
+			break;
+
+		case FreeRDP_ServerLicenseProductVersion:
+			settings->ServerLicenseProductVersion = cnv.c;
+			break;
+
+		case FreeRDP_ServerPort:
+			settings->ServerPort = cnv.c;
+			break;
+
+		case FreeRDP_ServerRandomLength:
+			settings->ServerRandomLength = cnv.c;
+			break;
+
+		case FreeRDP_ShareId:
+			settings->ShareId = cnv.c;
+			break;
+
+		case FreeRDP_SmartSizingHeight:
+			settings->SmartSizingHeight = cnv.c;
+			break;
+
+		case FreeRDP_SmartSizingWidth:
+			settings->SmartSizingWidth = cnv.c;
+			break;
+
+		case FreeRDP_StaticChannelArraySize:
+			settings->StaticChannelArraySize = cnv.c;
+			break;
+
+		case FreeRDP_StaticChannelCount:
+			settings->StaticChannelCount = cnv.c;
+			break;
+
+		case FreeRDP_TargetNetAddressCount:
+			settings->TargetNetAddressCount = cnv.c;
+			break;
+
+		case FreeRDP_TcpAckTimeout:
+			settings->TcpAckTimeout = cnv.c;
+			break;
+
+		case FreeRDP_TcpConnectTimeout:
+			settings->TcpConnectTimeout = cnv.c;
+			break;
+
+		case FreeRDP_TcpKeepAliveDelay:
+			settings->TcpKeepAliveDelay = cnv.c;
+			break;
+
+		case FreeRDP_TcpKeepAliveInterval:
+			settings->TcpKeepAliveInterval = cnv.c;
+			break;
+
+		case FreeRDP_TcpKeepAliveRetries:
+			settings->TcpKeepAliveRetries = cnv.c;
+			break;
+
+		case FreeRDP_ThreadingFlags:
+			settings->ThreadingFlags = cnv.c;
+			break;
+
+		case FreeRDP_TlsSecLevel:
+			settings->TlsSecLevel = cnv.c;
+			break;
+
+		case FreeRDP_VCChunkSize:
+			settings->VCChunkSize = cnv.c;
+			break;
+
+		case FreeRDP_VCFlags:
+			settings->VCFlags = cnv.c;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+INT32 freerdp_settings_get_int32(const rdpSettings* settings, FreeRDP_Settings_Keys_Int32 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_XPan:
+			return settings->XPan;
+
+		case FreeRDP_YPan:
+			return settings->YPan;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_int32(rdpSettings* settings, FreeRDP_Settings_Keys_Int32 id, INT32 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		INT32 c;
+		const INT32 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		case FreeRDP_XPan:
+			settings->XPan = cnv.c;
+			break;
+
+		case FreeRDP_YPan:
+			settings->YPan = cnv.c;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+UINT64 freerdp_settings_get_uint64(const rdpSettings* settings, FreeRDP_Settings_Keys_UInt64 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_ParentWindowId:
+			return settings->ParentWindowId;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_uint64(rdpSettings* settings, FreeRDP_Settings_Keys_UInt64 id, UINT64 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		UINT64 c;
+		const UINT64 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		case FreeRDP_ParentWindowId:
+			settings->ParentWindowId = cnv.c;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+INT64 freerdp_settings_get_int64(const rdpSettings* settings, FreeRDP_Settings_Keys_Int64 id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return 0;
+	}
+}
+
+BOOL freerdp_settings_set_int64(rdpSettings* settings, FreeRDP_Settings_Keys_Int64 id, INT64 val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		INT64 c;
+		const INT64 cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.c = val;
+
+	switch (id)
+	{
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+const char* freerdp_settings_get_string(const rdpSettings* settings,
+                                        FreeRDP_Settings_Keys_String id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_AadServerHostname:
+			return settings->AadServerHostname;
+
+		case FreeRDP_AcceptedCert:
+			return settings->AcceptedCert;
+
+		case FreeRDP_ActionScript:
+			return settings->ActionScript;
+
+		case FreeRDP_AllowedTlsCiphers:
+			return settings->AllowedTlsCiphers;
+
+		case FreeRDP_AlternateShell:
+			return settings->AlternateShell;
+
+		case FreeRDP_AssistanceFile:
+			return settings->AssistanceFile;
+
+		case FreeRDP_AuthenticationPackageList:
+			return settings->AuthenticationPackageList;
+
+		case FreeRDP_AuthenticationServiceClass:
+			return settings->AuthenticationServiceClass;
+
+		case FreeRDP_BitmapCachePersistFile:
+			return settings->BitmapCachePersistFile;
+
+		case FreeRDP_CardName:
+			return settings->CardName;
+
+		case FreeRDP_CertificateAcceptedFingerprints:
+			return settings->CertificateAcceptedFingerprints;
+
+		case FreeRDP_CertificateName:
+			return settings->CertificateName;
+
+		case FreeRDP_ClientAddress:
+			return settings->ClientAddress;
+
+		case FreeRDP_ClientDir:
+			return settings->ClientDir;
+
+		case FreeRDP_ClientHostname:
+			return settings->ClientHostname;
+
+		case FreeRDP_ClientProductId:
+			return settings->ClientProductId;
+
+		case FreeRDP_ClipboardUseSelection:
+			return settings->ClipboardUseSelection;
+
+		case FreeRDP_ComputerName:
+			return settings->ComputerName;
+
+		case FreeRDP_ConfigPath:
+			return settings->ConfigPath;
+
+		case FreeRDP_ConnectionFile:
+			return settings->ConnectionFile;
+
+		case FreeRDP_ContainerName:
+			return settings->ContainerName;
+
+		case FreeRDP_CspName:
+			return settings->CspName;
+
+		case FreeRDP_CurrentPath:
+			return settings->CurrentPath;
+
+		case FreeRDP_Domain:
+			return settings->Domain;
+
+		case FreeRDP_DrivesToRedirect:
+			return settings->DrivesToRedirect;
+
+		case FreeRDP_DumpRemoteFxFile:
+			return settings->DumpRemoteFxFile;
+
+		case FreeRDP_DynamicDSTTimeZoneKeyName:
+			return settings->DynamicDSTTimeZoneKeyName;
+
+		case FreeRDP_GatewayAcceptedCert:
+			return settings->GatewayAcceptedCert;
+
+		case FreeRDP_GatewayAccessToken:
+			return settings->GatewayAccessToken;
+
+		case FreeRDP_GatewayAvdAadtenantid:
+			return settings->GatewayAvdAadtenantid;
+
+		case FreeRDP_GatewayAvdActivityhint:
+			return settings->GatewayAvdActivityhint;
+
+		case FreeRDP_GatewayAvdArmpath:
+			return settings->GatewayAvdArmpath;
+
+		case FreeRDP_GatewayAvdDiagnosticserviceurl:
+			return settings->GatewayAvdDiagnosticserviceurl;
+
+		case FreeRDP_GatewayAvdGeo:
+			return settings->GatewayAvdGeo;
+
+		case FreeRDP_GatewayAvdHubdiscoverygeourl:
+			return settings->GatewayAvdHubdiscoverygeourl;
+
+		case FreeRDP_GatewayAvdWvdEndpointPool:
+			return settings->GatewayAvdWvdEndpointPool;
+
+		case FreeRDP_GatewayDomain:
+			return settings->GatewayDomain;
+
+		case FreeRDP_GatewayHostname:
+			return settings->GatewayHostname;
+
+		case FreeRDP_GatewayHttpExtAuthBearer:
+			return settings->GatewayHttpExtAuthBearer;
+
+		case FreeRDP_GatewayPassword:
+			return settings->GatewayPassword;
+
+		case FreeRDP_GatewayUrl:
+			return settings->GatewayUrl;
+
+		case FreeRDP_GatewayUsername:
+			return settings->GatewayUsername;
+
+		case FreeRDP_HomePath:
+			return settings->HomePath;
+
+		case FreeRDP_ImeFileName:
+			return settings->ImeFileName;
+
+		case FreeRDP_KerberosArmor:
+			return settings->KerberosArmor;
+
+		case FreeRDP_KerberosCache:
+			return settings->KerberosCache;
+
+		case FreeRDP_KerberosKdcUrl:
+			return settings->KerberosKdcUrl;
+
+		case FreeRDP_KerberosKeytab:
+			return settings->KerberosKeytab;
+
+		case FreeRDP_KerberosLifeTime:
+			return settings->KerberosLifeTime;
+
+		case FreeRDP_KerberosRealm:
+			return settings->KerberosRealm;
+
+		case FreeRDP_KerberosRenewableLifeTime:
+			return settings->KerberosRenewableLifeTime;
+
+		case FreeRDP_KerberosStartTime:
+			return settings->KerberosStartTime;
+
+		case FreeRDP_KeyboardPipeName:
+			return settings->KeyboardPipeName;
+
+		case FreeRDP_KeyboardRemappingList:
+			return settings->KeyboardRemappingList;
+
+		case FreeRDP_NtlmSamFile:
+			return settings->NtlmSamFile;
+
+		case FreeRDP_Password:
+			return settings->Password;
+
+		case FreeRDP_PasswordHash:
+			return settings->PasswordHash;
+
+		case FreeRDP_Pkcs11Module:
+			return settings->Pkcs11Module;
+
+		case FreeRDP_PkinitAnchors:
+			return settings->PkinitAnchors;
+
+		case FreeRDP_PlayRemoteFxFile:
+			return settings->PlayRemoteFxFile;
+
+		case FreeRDP_PreconnectionBlob:
+			return settings->PreconnectionBlob;
+
+		case FreeRDP_ProxyHostname:
+			return settings->ProxyHostname;
+
+		case FreeRDP_ProxyPassword:
+			return settings->ProxyPassword;
+
+		case FreeRDP_ProxyUsername:
+			return settings->ProxyUsername;
+
+		case FreeRDP_RDP2TCPArgs:
+			return settings->RDP2TCPArgs;
+
+		case FreeRDP_ReaderName:
+			return settings->ReaderName;
+
+		case FreeRDP_RedirectionAcceptedCert:
+			return settings->RedirectionAcceptedCert;
+
+		case FreeRDP_RedirectionDomain:
+			return settings->RedirectionDomain;
+
+		case FreeRDP_RedirectionTargetFQDN:
+			return settings->RedirectionTargetFQDN;
+
+		case FreeRDP_RedirectionTargetNetBiosName:
+			return settings->RedirectionTargetNetBiosName;
+
+		case FreeRDP_RedirectionUsername:
+			return settings->RedirectionUsername;
+
+		case FreeRDP_RemoteApplicationCmdLine:
+			return settings->RemoteApplicationCmdLine;
+
+		case FreeRDP_RemoteApplicationFile:
+			return settings->RemoteApplicationFile;
+
+		case FreeRDP_RemoteApplicationGuid:
+			return settings->RemoteApplicationGuid;
+
+		case FreeRDP_RemoteApplicationIcon:
+			return settings->RemoteApplicationIcon;
+
+		case FreeRDP_RemoteApplicationName:
+			return settings->RemoteApplicationName;
+
+		case FreeRDP_RemoteApplicationProgram:
+			return settings->RemoteApplicationProgram;
+
+		case FreeRDP_RemoteApplicationWorkingDir:
+			return settings->RemoteApplicationWorkingDir;
+
+		case FreeRDP_RemoteAssistancePassStub:
+			return settings->RemoteAssistancePassStub;
+
+		case FreeRDP_RemoteAssistancePassword:
+			return settings->RemoteAssistancePassword;
+
+		case FreeRDP_RemoteAssistanceRCTicket:
+			return settings->RemoteAssistanceRCTicket;
+
+		case FreeRDP_RemoteAssistanceSessionId:
+			return settings->RemoteAssistanceSessionId;
+
+		case FreeRDP_ServerHostname:
+			return settings->ServerHostname;
+
+		case FreeRDP_ServerLicenseCompanyName:
+			return settings->ServerLicenseCompanyName;
+
+		case FreeRDP_ServerLicenseProductName:
+			return settings->ServerLicenseProductName;
+
+		case FreeRDP_ShellWorkingDirectory:
+			return settings->ShellWorkingDirectory;
+
+		case FreeRDP_SmartcardCertificate:
+			return settings->SmartcardCertificate;
+
+		case FreeRDP_SmartcardPrivateKey:
+			return settings->SmartcardPrivateKey;
+
+		case FreeRDP_SspiModule:
+			return settings->SspiModule;
+
+		case FreeRDP_TargetNetAddress:
+			return settings->TargetNetAddress;
+
+		case FreeRDP_TerminalDescriptor:
+			return settings->TerminalDescriptor;
+
+		case FreeRDP_TlsSecretsFile:
+			return settings->TlsSecretsFile;
+
+		case FreeRDP_TransportDumpFile:
+			return settings->TransportDumpFile;
+
+		case FreeRDP_UserSpecifiedServerName:
+			return settings->UserSpecifiedServerName;
+
+		case FreeRDP_Username:
+			return settings->Username;
+
+		case FreeRDP_WinSCardModule:
+			return settings->WinSCardModule;
+
+		case FreeRDP_WindowTitle:
+			return settings->WindowTitle;
+
+		case FreeRDP_WmClass:
+			return settings->WmClass;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return NULL;
+	}
+}
+
+char* freerdp_settings_get_string_writable(rdpSettings* settings, FreeRDP_Settings_Keys_String id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_AadServerHostname:
+			return settings->AadServerHostname;
+
+		case FreeRDP_AcceptedCert:
+			return settings->AcceptedCert;
+
+		case FreeRDP_ActionScript:
+			return settings->ActionScript;
+
+		case FreeRDP_AllowedTlsCiphers:
+			return settings->AllowedTlsCiphers;
+
+		case FreeRDP_AlternateShell:
+			return settings->AlternateShell;
+
+		case FreeRDP_AssistanceFile:
+			return settings->AssistanceFile;
+
+		case FreeRDP_AuthenticationPackageList:
+			return settings->AuthenticationPackageList;
+
+		case FreeRDP_AuthenticationServiceClass:
+			return settings->AuthenticationServiceClass;
+
+		case FreeRDP_BitmapCachePersistFile:
+			return settings->BitmapCachePersistFile;
+
+		case FreeRDP_CardName:
+			return settings->CardName;
+
+		case FreeRDP_CertificateAcceptedFingerprints:
+			return settings->CertificateAcceptedFingerprints;
+
+		case FreeRDP_CertificateName:
+			return settings->CertificateName;
+
+		case FreeRDP_ClientAddress:
+			return settings->ClientAddress;
+
+		case FreeRDP_ClientDir:
+			return settings->ClientDir;
+
+		case FreeRDP_ClientHostname:
+			return settings->ClientHostname;
+
+		case FreeRDP_ClientProductId:
+			return settings->ClientProductId;
+
+		case FreeRDP_ClipboardUseSelection:
+			return settings->ClipboardUseSelection;
+
+		case FreeRDP_ComputerName:
+			return settings->ComputerName;
+
+		case FreeRDP_ConfigPath:
+			return settings->ConfigPath;
+
+		case FreeRDP_ConnectionFile:
+			return settings->ConnectionFile;
+
+		case FreeRDP_ContainerName:
+			return settings->ContainerName;
+
+		case FreeRDP_CspName:
+			return settings->CspName;
+
+		case FreeRDP_CurrentPath:
+			return settings->CurrentPath;
+
+		case FreeRDP_Domain:
+			return settings->Domain;
+
+		case FreeRDP_DrivesToRedirect:
+			return settings->DrivesToRedirect;
+
+		case FreeRDP_DumpRemoteFxFile:
+			return settings->DumpRemoteFxFile;
+
+		case FreeRDP_DynamicDSTTimeZoneKeyName:
+			return settings->DynamicDSTTimeZoneKeyName;
+
+		case FreeRDP_GatewayAcceptedCert:
+			return settings->GatewayAcceptedCert;
+
+		case FreeRDP_GatewayAccessToken:
+			return settings->GatewayAccessToken;
+
+		case FreeRDP_GatewayAvdAadtenantid:
+			return settings->GatewayAvdAadtenantid;
+
+		case FreeRDP_GatewayAvdActivityhint:
+			return settings->GatewayAvdActivityhint;
+
+		case FreeRDP_GatewayAvdArmpath:
+			return settings->GatewayAvdArmpath;
+
+		case FreeRDP_GatewayAvdDiagnosticserviceurl:
+			return settings->GatewayAvdDiagnosticserviceurl;
+
+		case FreeRDP_GatewayAvdGeo:
+			return settings->GatewayAvdGeo;
+
+		case FreeRDP_GatewayAvdHubdiscoverygeourl:
+			return settings->GatewayAvdHubdiscoverygeourl;
+
+		case FreeRDP_GatewayAvdWvdEndpointPool:
+			return settings->GatewayAvdWvdEndpointPool;
+
+		case FreeRDP_GatewayDomain:
+			return settings->GatewayDomain;
+
+		case FreeRDP_GatewayHostname:
+			return settings->GatewayHostname;
+
+		case FreeRDP_GatewayHttpExtAuthBearer:
+			return settings->GatewayHttpExtAuthBearer;
+
+		case FreeRDP_GatewayPassword:
+			return settings->GatewayPassword;
+
+		case FreeRDP_GatewayUrl:
+			return settings->GatewayUrl;
+
+		case FreeRDP_GatewayUsername:
+			return settings->GatewayUsername;
+
+		case FreeRDP_HomePath:
+			return settings->HomePath;
+
+		case FreeRDP_ImeFileName:
+			return settings->ImeFileName;
+
+		case FreeRDP_KerberosArmor:
+			return settings->KerberosArmor;
+
+		case FreeRDP_KerberosCache:
+			return settings->KerberosCache;
+
+		case FreeRDP_KerberosKdcUrl:
+			return settings->KerberosKdcUrl;
+
+		case FreeRDP_KerberosKeytab:
+			return settings->KerberosKeytab;
+
+		case FreeRDP_KerberosLifeTime:
+			return settings->KerberosLifeTime;
+
+		case FreeRDP_KerberosRealm:
+			return settings->KerberosRealm;
+
+		case FreeRDP_KerberosRenewableLifeTime:
+			return settings->KerberosRenewableLifeTime;
+
+		case FreeRDP_KerberosStartTime:
+			return settings->KerberosStartTime;
+
+		case FreeRDP_KeyboardPipeName:
+			return settings->KeyboardPipeName;
+
+		case FreeRDP_KeyboardRemappingList:
+			return settings->KeyboardRemappingList;
+
+		case FreeRDP_NtlmSamFile:
+			return settings->NtlmSamFile;
+
+		case FreeRDP_Password:
+			return settings->Password;
+
+		case FreeRDP_PasswordHash:
+			return settings->PasswordHash;
+
+		case FreeRDP_Pkcs11Module:
+			return settings->Pkcs11Module;
+
+		case FreeRDP_PkinitAnchors:
+			return settings->PkinitAnchors;
+
+		case FreeRDP_PlayRemoteFxFile:
+			return settings->PlayRemoteFxFile;
+
+		case FreeRDP_PreconnectionBlob:
+			return settings->PreconnectionBlob;
+
+		case FreeRDP_ProxyHostname:
+			return settings->ProxyHostname;
+
+		case FreeRDP_ProxyPassword:
+			return settings->ProxyPassword;
+
+		case FreeRDP_ProxyUsername:
+			return settings->ProxyUsername;
+
+		case FreeRDP_RDP2TCPArgs:
+			return settings->RDP2TCPArgs;
+
+		case FreeRDP_ReaderName:
+			return settings->ReaderName;
+
+		case FreeRDP_RedirectionAcceptedCert:
+			return settings->RedirectionAcceptedCert;
+
+		case FreeRDP_RedirectionDomain:
+			return settings->RedirectionDomain;
+
+		case FreeRDP_RedirectionTargetFQDN:
+			return settings->RedirectionTargetFQDN;
+
+		case FreeRDP_RedirectionTargetNetBiosName:
+			return settings->RedirectionTargetNetBiosName;
+
+		case FreeRDP_RedirectionUsername:
+			return settings->RedirectionUsername;
+
+		case FreeRDP_RemoteApplicationCmdLine:
+			return settings->RemoteApplicationCmdLine;
+
+		case FreeRDP_RemoteApplicationFile:
+			return settings->RemoteApplicationFile;
+
+		case FreeRDP_RemoteApplicationGuid:
+			return settings->RemoteApplicationGuid;
+
+		case FreeRDP_RemoteApplicationIcon:
+			return settings->RemoteApplicationIcon;
+
+		case FreeRDP_RemoteApplicationName:
+			return settings->RemoteApplicationName;
+
+		case FreeRDP_RemoteApplicationProgram:
+			return settings->RemoteApplicationProgram;
+
+		case FreeRDP_RemoteApplicationWorkingDir:
+			return settings->RemoteApplicationWorkingDir;
+
+		case FreeRDP_RemoteAssistancePassStub:
+			return settings->RemoteAssistancePassStub;
+
+		case FreeRDP_RemoteAssistancePassword:
+			return settings->RemoteAssistancePassword;
+
+		case FreeRDP_RemoteAssistanceRCTicket:
+			return settings->RemoteAssistanceRCTicket;
+
+		case FreeRDP_RemoteAssistanceSessionId:
+			return settings->RemoteAssistanceSessionId;
+
+		case FreeRDP_ServerHostname:
+			return settings->ServerHostname;
+
+		case FreeRDP_ServerLicenseCompanyName:
+			return settings->ServerLicenseCompanyName;
+
+		case FreeRDP_ServerLicenseProductName:
+			return settings->ServerLicenseProductName;
+
+		case FreeRDP_ShellWorkingDirectory:
+			return settings->ShellWorkingDirectory;
+
+		case FreeRDP_SmartcardCertificate:
+			return settings->SmartcardCertificate;
+
+		case FreeRDP_SmartcardPrivateKey:
+			return settings->SmartcardPrivateKey;
+
+		case FreeRDP_SspiModule:
+			return settings->SspiModule;
+
+		case FreeRDP_TargetNetAddress:
+			return settings->TargetNetAddress;
+
+		case FreeRDP_TerminalDescriptor:
+			return settings->TerminalDescriptor;
+
+		case FreeRDP_TlsSecretsFile:
+			return settings->TlsSecretsFile;
+
+		case FreeRDP_TransportDumpFile:
+			return settings->TransportDumpFile;
+
+		case FreeRDP_UserSpecifiedServerName:
+			return settings->UserSpecifiedServerName;
+
+		case FreeRDP_Username:
+			return settings->Username;
+
+		case FreeRDP_WinSCardModule:
+			return settings->WinSCardModule;
+
+		case FreeRDP_WindowTitle:
+			return settings->WindowTitle;
+
+		case FreeRDP_WmClass:
+			return settings->WmClass;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return NULL;
+	}
+}
+
+BOOL freerdp_settings_set_string_(rdpSettings* settings, FreeRDP_Settings_Keys_String id, char* val,
+                                  size_t len)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		char* c;
+		const char* cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.cc = val;
+
+	switch (id)
+	{
+		case FreeRDP_AadServerHostname:
+			return update_string_(&settings->AadServerHostname, cnv.c, len);
+
+		case FreeRDP_AcceptedCert:
+			return update_string_(&settings->AcceptedCert, cnv.c, len);
+
+		case FreeRDP_ActionScript:
+			return update_string_(&settings->ActionScript, cnv.c, len);
+
+		case FreeRDP_AllowedTlsCiphers:
+			return update_string_(&settings->AllowedTlsCiphers, cnv.c, len);
+
+		case FreeRDP_AlternateShell:
+			return update_string_(&settings->AlternateShell, cnv.c, len);
+
+		case FreeRDP_AssistanceFile:
+			return update_string_(&settings->AssistanceFile, cnv.c, len);
+
+		case FreeRDP_AuthenticationPackageList:
+			return update_string_(&settings->AuthenticationPackageList, cnv.c, len);
+
+		case FreeRDP_AuthenticationServiceClass:
+			return update_string_(&settings->AuthenticationServiceClass, cnv.c, len);
+
+		case FreeRDP_BitmapCachePersistFile:
+			return update_string_(&settings->BitmapCachePersistFile, cnv.c, len);
+
+		case FreeRDP_CardName:
+			return update_string_(&settings->CardName, cnv.c, len);
+
+		case FreeRDP_CertificateAcceptedFingerprints:
+			return update_string_(&settings->CertificateAcceptedFingerprints, cnv.c, len);
+
+		case FreeRDP_CertificateName:
+			return update_string_(&settings->CertificateName, cnv.c, len);
+
+		case FreeRDP_ClientAddress:
+			return update_string_(&settings->ClientAddress, cnv.c, len);
+
+		case FreeRDP_ClientDir:
+			return update_string_(&settings->ClientDir, cnv.c, len);
+
+		case FreeRDP_ClientHostname:
+			return update_string_(&settings->ClientHostname, cnv.c, len);
+
+		case FreeRDP_ClientProductId:
+			return update_string_(&settings->ClientProductId, cnv.c, len);
+
+		case FreeRDP_ClipboardUseSelection:
+			return update_string_(&settings->ClipboardUseSelection, cnv.c, len);
+
+		case FreeRDP_ComputerName:
+			return update_string_(&settings->ComputerName, cnv.c, len);
+
+		case FreeRDP_ConfigPath:
+			return update_string_(&settings->ConfigPath, cnv.c, len);
+
+		case FreeRDP_ConnectionFile:
+			return update_string_(&settings->ConnectionFile, cnv.c, len);
+
+		case FreeRDP_ContainerName:
+			return update_string_(&settings->ContainerName, cnv.c, len);
+
+		case FreeRDP_CspName:
+			return update_string_(&settings->CspName, cnv.c, len);
+
+		case FreeRDP_CurrentPath:
+			return update_string_(&settings->CurrentPath, cnv.c, len);
+
+		case FreeRDP_Domain:
+			return update_string_(&settings->Domain, cnv.c, len);
+
+		case FreeRDP_DrivesToRedirect:
+			return update_string_(&settings->DrivesToRedirect, cnv.c, len);
+
+		case FreeRDP_DumpRemoteFxFile:
+			return update_string_(&settings->DumpRemoteFxFile, cnv.c, len);
+
+		case FreeRDP_DynamicDSTTimeZoneKeyName:
+			return update_string_(&settings->DynamicDSTTimeZoneKeyName, cnv.c, len);
+
+		case FreeRDP_GatewayAcceptedCert:
+			return update_string_(&settings->GatewayAcceptedCert, cnv.c, len);
+
+		case FreeRDP_GatewayAccessToken:
+			return update_string_(&settings->GatewayAccessToken, cnv.c, len);
+
+		case FreeRDP_GatewayAvdAadtenantid:
+			return update_string_(&settings->GatewayAvdAadtenantid, cnv.c, len);
+
+		case FreeRDP_GatewayAvdActivityhint:
+			return update_string_(&settings->GatewayAvdActivityhint, cnv.c, len);
+
+		case FreeRDP_GatewayAvdArmpath:
+			return update_string_(&settings->GatewayAvdArmpath, cnv.c, len);
+
+		case FreeRDP_GatewayAvdDiagnosticserviceurl:
+			return update_string_(&settings->GatewayAvdDiagnosticserviceurl, cnv.c, len);
+
+		case FreeRDP_GatewayAvdGeo:
+			return update_string_(&settings->GatewayAvdGeo, cnv.c, len);
+
+		case FreeRDP_GatewayAvdHubdiscoverygeourl:
+			return update_string_(&settings->GatewayAvdHubdiscoverygeourl, cnv.c, len);
+
+		case FreeRDP_GatewayAvdWvdEndpointPool:
+			return update_string_(&settings->GatewayAvdWvdEndpointPool, cnv.c, len);
+
+		case FreeRDP_GatewayDomain:
+			return update_string_(&settings->GatewayDomain, cnv.c, len);
+
+		case FreeRDP_GatewayHostname:
+			return update_string_(&settings->GatewayHostname, cnv.c, len);
+
+		case FreeRDP_GatewayHttpExtAuthBearer:
+			return update_string_(&settings->GatewayHttpExtAuthBearer, cnv.c, len);
+
+		case FreeRDP_GatewayPassword:
+			return update_string_(&settings->GatewayPassword, cnv.c, len);
+
+		case FreeRDP_GatewayUrl:
+			return update_string_(&settings->GatewayUrl, cnv.c, len);
+
+		case FreeRDP_GatewayUsername:
+			return update_string_(&settings->GatewayUsername, cnv.c, len);
+
+		case FreeRDP_HomePath:
+			return update_string_(&settings->HomePath, cnv.c, len);
+
+		case FreeRDP_ImeFileName:
+			return update_string_(&settings->ImeFileName, cnv.c, len);
+
+		case FreeRDP_KerberosArmor:
+			return update_string_(&settings->KerberosArmor, cnv.c, len);
+
+		case FreeRDP_KerberosCache:
+			return update_string_(&settings->KerberosCache, cnv.c, len);
+
+		case FreeRDP_KerberosKdcUrl:
+			return update_string_(&settings->KerberosKdcUrl, cnv.c, len);
+
+		case FreeRDP_KerberosKeytab:
+			return update_string_(&settings->KerberosKeytab, cnv.c, len);
+
+		case FreeRDP_KerberosLifeTime:
+			return update_string_(&settings->KerberosLifeTime, cnv.c, len);
+
+		case FreeRDP_KerberosRealm:
+			return update_string_(&settings->KerberosRealm, cnv.c, len);
+
+		case FreeRDP_KerberosRenewableLifeTime:
+			return update_string_(&settings->KerberosRenewableLifeTime, cnv.c, len);
+
+		case FreeRDP_KerberosStartTime:
+			return update_string_(&settings->KerberosStartTime, cnv.c, len);
+
+		case FreeRDP_KeyboardPipeName:
+			return update_string_(&settings->KeyboardPipeName, cnv.c, len);
+
+		case FreeRDP_KeyboardRemappingList:
+			return update_string_(&settings->KeyboardRemappingList, cnv.c, len);
+
+		case FreeRDP_NtlmSamFile:
+			return update_string_(&settings->NtlmSamFile, cnv.c, len);
+
+		case FreeRDP_Password:
+			return update_string_(&settings->Password, cnv.c, len);
+
+		case FreeRDP_PasswordHash:
+			return update_string_(&settings->PasswordHash, cnv.c, len);
+
+		case FreeRDP_Pkcs11Module:
+			return update_string_(&settings->Pkcs11Module, cnv.c, len);
+
+		case FreeRDP_PkinitAnchors:
+			return update_string_(&settings->PkinitAnchors, cnv.c, len);
+
+		case FreeRDP_PlayRemoteFxFile:
+			return update_string_(&settings->PlayRemoteFxFile, cnv.c, len);
+
+		case FreeRDP_PreconnectionBlob:
+			return update_string_(&settings->PreconnectionBlob, cnv.c, len);
+
+		case FreeRDP_ProxyHostname:
+			return update_string_(&settings->ProxyHostname, cnv.c, len);
+
+		case FreeRDP_ProxyPassword:
+			return update_string_(&settings->ProxyPassword, cnv.c, len);
+
+		case FreeRDP_ProxyUsername:
+			return update_string_(&settings->ProxyUsername, cnv.c, len);
+
+		case FreeRDP_RDP2TCPArgs:
+			return update_string_(&settings->RDP2TCPArgs, cnv.c, len);
+
+		case FreeRDP_ReaderName:
+			return update_string_(&settings->ReaderName, cnv.c, len);
+
+		case FreeRDP_RedirectionAcceptedCert:
+			return update_string_(&settings->RedirectionAcceptedCert, cnv.c, len);
+
+		case FreeRDP_RedirectionDomain:
+			return update_string_(&settings->RedirectionDomain, cnv.c, len);
+
+		case FreeRDP_RedirectionTargetFQDN:
+			return update_string_(&settings->RedirectionTargetFQDN, cnv.c, len);
+
+		case FreeRDP_RedirectionTargetNetBiosName:
+			return update_string_(&settings->RedirectionTargetNetBiosName, cnv.c, len);
+
+		case FreeRDP_RedirectionUsername:
+			return update_string_(&settings->RedirectionUsername, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationCmdLine:
+			return update_string_(&settings->RemoteApplicationCmdLine, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationFile:
+			return update_string_(&settings->RemoteApplicationFile, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationGuid:
+			return update_string_(&settings->RemoteApplicationGuid, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationIcon:
+			return update_string_(&settings->RemoteApplicationIcon, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationName:
+			return update_string_(&settings->RemoteApplicationName, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationProgram:
+			return update_string_(&settings->RemoteApplicationProgram, cnv.c, len);
+
+		case FreeRDP_RemoteApplicationWorkingDir:
+			return update_string_(&settings->RemoteApplicationWorkingDir, cnv.c, len);
+
+		case FreeRDP_RemoteAssistancePassStub:
+			return update_string_(&settings->RemoteAssistancePassStub, cnv.c, len);
+
+		case FreeRDP_RemoteAssistancePassword:
+			return update_string_(&settings->RemoteAssistancePassword, cnv.c, len);
+
+		case FreeRDP_RemoteAssistanceRCTicket:
+			return update_string_(&settings->RemoteAssistanceRCTicket, cnv.c, len);
+
+		case FreeRDP_RemoteAssistanceSessionId:
+			return update_string_(&settings->RemoteAssistanceSessionId, cnv.c, len);
+
+		case FreeRDP_ServerHostname:
+			return update_string_(&settings->ServerHostname, cnv.c, len);
+
+		case FreeRDP_ServerLicenseCompanyName:
+			return update_string_(&settings->ServerLicenseCompanyName, cnv.c, len);
+
+		case FreeRDP_ServerLicenseProductName:
+			return update_string_(&settings->ServerLicenseProductName, cnv.c, len);
+
+		case FreeRDP_ShellWorkingDirectory:
+			return update_string_(&settings->ShellWorkingDirectory, cnv.c, len);
+
+		case FreeRDP_SmartcardCertificate:
+			return update_string_(&settings->SmartcardCertificate, cnv.c, len);
+
+		case FreeRDP_SmartcardPrivateKey:
+			return update_string_(&settings->SmartcardPrivateKey, cnv.c, len);
+
+		case FreeRDP_SspiModule:
+			return update_string_(&settings->SspiModule, cnv.c, len);
+
+		case FreeRDP_TargetNetAddress:
+			return update_string_(&settings->TargetNetAddress, cnv.c, len);
+
+		case FreeRDP_TerminalDescriptor:
+			return update_string_(&settings->TerminalDescriptor, cnv.c, len);
+
+		case FreeRDP_TlsSecretsFile:
+			return update_string_(&settings->TlsSecretsFile, cnv.c, len);
+
+		case FreeRDP_TransportDumpFile:
+			return update_string_(&settings->TransportDumpFile, cnv.c, len);
+
+		case FreeRDP_UserSpecifiedServerName:
+			return update_string_(&settings->UserSpecifiedServerName, cnv.c, len);
+
+		case FreeRDP_Username:
+			return update_string_(&settings->Username, cnv.c, len);
+
+		case FreeRDP_WinSCardModule:
+			return update_string_(&settings->WinSCardModule, cnv.c, len);
+
+		case FreeRDP_WindowTitle:
+			return update_string_(&settings->WindowTitle, cnv.c, len);
+
+		case FreeRDP_WmClass:
+			return update_string_(&settings->WmClass, cnv.c, len);
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+BOOL freerdp_settings_set_string_len(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                     const char* val, size_t len)
+{
+	return freerdp_settings_set_string_copy_(settings, id, val, len, TRUE);
+}
+
+BOOL freerdp_settings_set_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                 const char* val)
+{
+	size_t len = 0;
+	if (val)
+		len = strlen(val);
+	return freerdp_settings_set_string_copy_(settings, id, val, len, TRUE);
+}
+
+BOOL freerdp_settings_set_string_copy_(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
+                                       const char* val, size_t len, BOOL cleanup)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+		char* c;
+		const char* cc;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.cc = val;
+
+	switch (id)
+	{
+		case FreeRDP_AadServerHostname:
+			return update_string_copy_(&settings->AadServerHostname, cnv.cc, len, cleanup);
+
+		case FreeRDP_AcceptedCert:
+			return update_string_copy_(&settings->AcceptedCert, cnv.cc, len, cleanup);
+
+		case FreeRDP_ActionScript:
+			return update_string_copy_(&settings->ActionScript, cnv.cc, len, cleanup);
+
+		case FreeRDP_AllowedTlsCiphers:
+			return update_string_copy_(&settings->AllowedTlsCiphers, cnv.cc, len, cleanup);
+
+		case FreeRDP_AlternateShell:
+			return update_string_copy_(&settings->AlternateShell, cnv.cc, len, cleanup);
+
+		case FreeRDP_AssistanceFile:
+			return update_string_copy_(&settings->AssistanceFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_AuthenticationPackageList:
+			return update_string_copy_(&settings->AuthenticationPackageList, cnv.cc, len, cleanup);
+
+		case FreeRDP_AuthenticationServiceClass:
+			return update_string_copy_(&settings->AuthenticationServiceClass, cnv.cc, len, cleanup);
+
+		case FreeRDP_BitmapCachePersistFile:
+			return update_string_copy_(&settings->BitmapCachePersistFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_CardName:
+			return update_string_copy_(&settings->CardName, cnv.cc, len, cleanup);
+
+		case FreeRDP_CertificateAcceptedFingerprints:
+			return update_string_copy_(&settings->CertificateAcceptedFingerprints, cnv.cc, len,
+			                           cleanup);
+
+		case FreeRDP_CertificateName:
+			return update_string_copy_(&settings->CertificateName, cnv.cc, len, cleanup);
+
+		case FreeRDP_ClientAddress:
+			return update_string_copy_(&settings->ClientAddress, cnv.cc, len, cleanup);
+
+		case FreeRDP_ClientDir:
+			return update_string_copy_(&settings->ClientDir, cnv.cc, len, cleanup);
+
+		case FreeRDP_ClientHostname:
+			return update_string_copy_(&settings->ClientHostname, cnv.cc, len, cleanup);
+
+		case FreeRDP_ClientProductId:
+			return update_string_copy_(&settings->ClientProductId, cnv.cc, len, cleanup);
+
+		case FreeRDP_ClipboardUseSelection:
+			return update_string_copy_(&settings->ClipboardUseSelection, cnv.cc, len, cleanup);
+
+		case FreeRDP_ComputerName:
+			return update_string_copy_(&settings->ComputerName, cnv.cc, len, cleanup);
+
+		case FreeRDP_ConfigPath:
+			return update_string_copy_(&settings->ConfigPath, cnv.cc, len, cleanup);
+
+		case FreeRDP_ConnectionFile:
+			return update_string_copy_(&settings->ConnectionFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_ContainerName:
+			return update_string_copy_(&settings->ContainerName, cnv.cc, len, cleanup);
+
+		case FreeRDP_CspName:
+			return update_string_copy_(&settings->CspName, cnv.cc, len, cleanup);
+
+		case FreeRDP_CurrentPath:
+			return update_string_copy_(&settings->CurrentPath, cnv.cc, len, cleanup);
+
+		case FreeRDP_Domain:
+			return update_string_copy_(&settings->Domain, cnv.cc, len, cleanup);
+
+		case FreeRDP_DrivesToRedirect:
+			return update_string_copy_(&settings->DrivesToRedirect, cnv.cc, len, cleanup);
+
+		case FreeRDP_DumpRemoteFxFile:
+			return update_string_copy_(&settings->DumpRemoteFxFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_DynamicDSTTimeZoneKeyName:
+			return update_string_copy_(&settings->DynamicDSTTimeZoneKeyName, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAcceptedCert:
+			return update_string_copy_(&settings->GatewayAcceptedCert, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAccessToken:
+			return update_string_copy_(&settings->GatewayAccessToken, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAvdAadtenantid:
+			return update_string_copy_(&settings->GatewayAvdAadtenantid, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAvdActivityhint:
+			return update_string_copy_(&settings->GatewayAvdActivityhint, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAvdArmpath:
+			return update_string_copy_(&settings->GatewayAvdArmpath, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAvdDiagnosticserviceurl:
+			return update_string_copy_(&settings->GatewayAvdDiagnosticserviceurl, cnv.cc, len,
+			                           cleanup);
+
+		case FreeRDP_GatewayAvdGeo:
+			return update_string_copy_(&settings->GatewayAvdGeo, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayAvdHubdiscoverygeourl:
+			return update_string_copy_(&settings->GatewayAvdHubdiscoverygeourl, cnv.cc, len,
+			                           cleanup);
+
+		case FreeRDP_GatewayAvdWvdEndpointPool:
+			return update_string_copy_(&settings->GatewayAvdWvdEndpointPool, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayDomain:
+			return update_string_copy_(&settings->GatewayDomain, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayHostname:
+			return update_string_copy_(&settings->GatewayHostname, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayHttpExtAuthBearer:
+			return update_string_copy_(&settings->GatewayHttpExtAuthBearer, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayPassword:
+			return update_string_copy_(&settings->GatewayPassword, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayUrl:
+			return update_string_copy_(&settings->GatewayUrl, cnv.cc, len, cleanup);
+
+		case FreeRDP_GatewayUsername:
+			return update_string_copy_(&settings->GatewayUsername, cnv.cc, len, cleanup);
+
+		case FreeRDP_HomePath:
+			return update_string_copy_(&settings->HomePath, cnv.cc, len, cleanup);
+
+		case FreeRDP_ImeFileName:
+			return update_string_copy_(&settings->ImeFileName, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosArmor:
+			return update_string_copy_(&settings->KerberosArmor, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosCache:
+			return update_string_copy_(&settings->KerberosCache, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosKdcUrl:
+			return update_string_copy_(&settings->KerberosKdcUrl, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosKeytab:
+			return update_string_copy_(&settings->KerberosKeytab, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosLifeTime:
+			return update_string_copy_(&settings->KerberosLifeTime, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosRealm:
+			return update_string_copy_(&settings->KerberosRealm, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosRenewableLifeTime:
+			return update_string_copy_(&settings->KerberosRenewableLifeTime, cnv.cc, len, cleanup);
+
+		case FreeRDP_KerberosStartTime:
+			return update_string_copy_(&settings->KerberosStartTime, cnv.cc, len, cleanup);
+
+		case FreeRDP_KeyboardPipeName:
+			return update_string_copy_(&settings->KeyboardPipeName, cnv.cc, len, cleanup);
+
+		case FreeRDP_KeyboardRemappingList:
+			return update_string_copy_(&settings->KeyboardRemappingList, cnv.cc, len, cleanup);
+
+		case FreeRDP_NtlmSamFile:
+			return update_string_copy_(&settings->NtlmSamFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_Password:
+			return update_string_copy_(&settings->Password, cnv.cc, len, cleanup);
+
+		case FreeRDP_PasswordHash:
+			return update_string_copy_(&settings->PasswordHash, cnv.cc, len, cleanup);
+
+		case FreeRDP_Pkcs11Module:
+			return update_string_copy_(&settings->Pkcs11Module, cnv.cc, len, cleanup);
+
+		case FreeRDP_PkinitAnchors:
+			return update_string_copy_(&settings->PkinitAnchors, cnv.cc, len, cleanup);
+
+		case FreeRDP_PlayRemoteFxFile:
+			return update_string_copy_(&settings->PlayRemoteFxFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_PreconnectionBlob:
+			return update_string_copy_(&settings->PreconnectionBlob, cnv.cc, len, cleanup);
+
+		case FreeRDP_ProxyHostname:
+			return update_string_copy_(&settings->ProxyHostname, cnv.cc, len, cleanup);
+
+		case FreeRDP_ProxyPassword:
+			return update_string_copy_(&settings->ProxyPassword, cnv.cc, len, cleanup);
+
+		case FreeRDP_ProxyUsername:
+			return update_string_copy_(&settings->ProxyUsername, cnv.cc, len, cleanup);
+
+		case FreeRDP_RDP2TCPArgs:
+			return update_string_copy_(&settings->RDP2TCPArgs, cnv.cc, len, cleanup);
+
+		case FreeRDP_ReaderName:
+			return update_string_copy_(&settings->ReaderName, cnv.cc, len, cleanup);
+
+		case FreeRDP_RedirectionAcceptedCert:
+			return update_string_copy_(&settings->RedirectionAcceptedCert, cnv.cc, len, cleanup);
+
+		case FreeRDP_RedirectionDomain:
+			return update_string_copy_(&settings->RedirectionDomain, cnv.cc, len, cleanup);
+
+		case FreeRDP_RedirectionTargetFQDN:
+			return update_string_copy_(&settings->RedirectionTargetFQDN, cnv.cc, len, cleanup);
+
+		case FreeRDP_RedirectionTargetNetBiosName:
+			return update_string_copy_(&settings->RedirectionTargetNetBiosName, cnv.cc, len,
+			                           cleanup);
+
+		case FreeRDP_RedirectionUsername:
+			return update_string_copy_(&settings->RedirectionUsername, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationCmdLine:
+			return update_string_copy_(&settings->RemoteApplicationCmdLine, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationFile:
+			return update_string_copy_(&settings->RemoteApplicationFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationGuid:
+			return update_string_copy_(&settings->RemoteApplicationGuid, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationIcon:
+			return update_string_copy_(&settings->RemoteApplicationIcon, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationName:
+			return update_string_copy_(&settings->RemoteApplicationName, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationProgram:
+			return update_string_copy_(&settings->RemoteApplicationProgram, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteApplicationWorkingDir:
+			return update_string_copy_(&settings->RemoteApplicationWorkingDir, cnv.cc, len,
+			                           cleanup);
+
+		case FreeRDP_RemoteAssistancePassStub:
+			return update_string_copy_(&settings->RemoteAssistancePassStub, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteAssistancePassword:
+			return update_string_copy_(&settings->RemoteAssistancePassword, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteAssistanceRCTicket:
+			return update_string_copy_(&settings->RemoteAssistanceRCTicket, cnv.cc, len, cleanup);
+
+		case FreeRDP_RemoteAssistanceSessionId:
+			return update_string_copy_(&settings->RemoteAssistanceSessionId, cnv.cc, len, cleanup);
+
+		case FreeRDP_ServerHostname:
+			return update_string_copy_(&settings->ServerHostname, cnv.cc, len, cleanup);
+
+		case FreeRDP_ServerLicenseCompanyName:
+			return update_string_copy_(&settings->ServerLicenseCompanyName, cnv.cc, len, cleanup);
+
+		case FreeRDP_ServerLicenseProductName:
+			return update_string_copy_(&settings->ServerLicenseProductName, cnv.cc, len, cleanup);
+
+		case FreeRDP_ShellWorkingDirectory:
+			return update_string_copy_(&settings->ShellWorkingDirectory, cnv.cc, len, cleanup);
+
+		case FreeRDP_SmartcardCertificate:
+			return update_string_copy_(&settings->SmartcardCertificate, cnv.cc, len, cleanup);
+
+		case FreeRDP_SmartcardPrivateKey:
+			return update_string_copy_(&settings->SmartcardPrivateKey, cnv.cc, len, cleanup);
+
+		case FreeRDP_SspiModule:
+			return update_string_copy_(&settings->SspiModule, cnv.cc, len, cleanup);
+
+		case FreeRDP_TargetNetAddress:
+			return update_string_copy_(&settings->TargetNetAddress, cnv.cc, len, cleanup);
+
+		case FreeRDP_TerminalDescriptor:
+			return update_string_copy_(&settings->TerminalDescriptor, cnv.cc, len, cleanup);
+
+		case FreeRDP_TlsSecretsFile:
+			return update_string_copy_(&settings->TlsSecretsFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_TransportDumpFile:
+			return update_string_copy_(&settings->TransportDumpFile, cnv.cc, len, cleanup);
+
+		case FreeRDP_UserSpecifiedServerName:
+			return update_string_copy_(&settings->UserSpecifiedServerName, cnv.cc, len, cleanup);
+
+		case FreeRDP_Username:
+			return update_string_copy_(&settings->Username, cnv.cc, len, cleanup);
+
+		case FreeRDP_WinSCardModule:
+			return update_string_copy_(&settings->WinSCardModule, cnv.cc, len, cleanup);
+
+		case FreeRDP_WindowTitle:
+			return update_string_copy_(&settings->WindowTitle, cnv.cc, len, cleanup);
+
+		case FreeRDP_WmClass:
+			return update_string_copy_(&settings->WmClass, cnv.cc, len, cleanup);
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
+
+void* freerdp_settings_get_pointer_writable(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id)
+{
+	WINPR_ASSERT(settings);
+
+	switch (id)
+	{
+		case FreeRDP_BitmapCacheV2CellInfo:
+			return settings->BitmapCacheV2CellInfo;
+
+		case FreeRDP_ChannelDefArray:
+			return settings->ChannelDefArray;
+
+		case FreeRDP_ClientAutoReconnectCookie:
+			return settings->ClientAutoReconnectCookie;
+
+		case FreeRDP_ClientRandom:
+			return settings->ClientRandom;
+
+		case FreeRDP_ClientTimeZone:
+			return settings->ClientTimeZone;
+
+		case FreeRDP_DeviceArray:
+			return settings->DeviceArray;
+
+		case FreeRDP_DynamicChannelArray:
+			return settings->DynamicChannelArray;
+
+		case FreeRDP_FragCache:
+			return settings->FragCache;
+
+		case FreeRDP_GlyphCache:
+			return settings->GlyphCache;
+
+		case FreeRDP_LoadBalanceInfo:
+			return settings->LoadBalanceInfo;
+
+		case FreeRDP_MonitorDefArray:
+			return settings->MonitorDefArray;
+
+		case FreeRDP_MonitorIds:
+			return settings->MonitorIds;
+
+		case FreeRDP_OrderSupport:
+			return settings->OrderSupport;
+
+		case FreeRDP_Password51:
+			return settings->Password51;
+
+		case FreeRDP_RdpServerCertificate:
+			return settings->RdpServerCertificate;
+
+		case FreeRDP_RdpServerRsaKey:
+			return settings->RdpServerRsaKey;
+
+		case FreeRDP_ReceivedCapabilities:
+			return settings->ReceivedCapabilities;
+
+		case FreeRDP_ReceivedCapabilityData:
+			return settings->ReceivedCapabilityData;
+
+		case FreeRDP_ReceivedCapabilityDataSizes:
+			return settings->ReceivedCapabilityDataSizes;
+
+		case FreeRDP_RedirectionGuid:
+			return settings->RedirectionGuid;
+
+		case FreeRDP_RedirectionPassword:
+			return settings->RedirectionPassword;
+
+		case FreeRDP_RedirectionTargetCertificate:
+			return settings->RedirectionTargetCertificate;
+
+		case FreeRDP_RedirectionTsvUrl:
+			return settings->RedirectionTsvUrl;
+
+		case FreeRDP_ServerAutoReconnectCookie:
+			return settings->ServerAutoReconnectCookie;
+
+		case FreeRDP_ServerCertificate:
+			return settings->ServerCertificate;
+
+		case FreeRDP_ServerLicenseProductIssuers:
+			return settings->ServerLicenseProductIssuers;
+
+		case FreeRDP_ServerRandom:
+			return settings->ServerRandom;
+
+		case FreeRDP_StaticChannelArray:
+			return settings->StaticChannelArray;
+
+		case FreeRDP_TargetNetAddresses:
+			return settings->TargetNetAddresses;
+
+		case FreeRDP_TargetNetPorts:
+			return settings->TargetNetPorts;
+
+		case FreeRDP_instance:
+			return settings->instance;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			WINPR_ASSERT(FALSE);
+			return NULL;
+	}
+}
+
+BOOL freerdp_settings_set_pointer(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
+                                  const void* val)
+{
+	union
+	{
+		void* v;
+		const void* cv;
+	} cnv;
+	WINPR_ASSERT(settings);
+
+	cnv.cv = val;
+
+	switch (id)
+	{
+		case FreeRDP_BitmapCacheV2CellInfo:
+			settings->BitmapCacheV2CellInfo = cnv.v;
+			break;
+
+		case FreeRDP_ChannelDefArray:
+			settings->ChannelDefArray = cnv.v;
+			break;
+
+		case FreeRDP_ClientAutoReconnectCookie:
+			settings->ClientAutoReconnectCookie = cnv.v;
+			break;
+
+		case FreeRDP_ClientRandom:
+			settings->ClientRandom = cnv.v;
+			break;
+
+		case FreeRDP_ClientTimeZone:
+			settings->ClientTimeZone = cnv.v;
+			break;
+
+		case FreeRDP_DeviceArray:
+			settings->DeviceArray = cnv.v;
+			break;
+
+		case FreeRDP_DynamicChannelArray:
+			settings->DynamicChannelArray = cnv.v;
+			break;
+
+		case FreeRDP_FragCache:
+			settings->FragCache = cnv.v;
+			break;
+
+		case FreeRDP_GlyphCache:
+			settings->GlyphCache = cnv.v;
+			break;
+
+		case FreeRDP_LoadBalanceInfo:
+			settings->LoadBalanceInfo = cnv.v;
+			break;
+
+		case FreeRDP_MonitorDefArray:
+			settings->MonitorDefArray = cnv.v;
+			break;
+
+		case FreeRDP_MonitorIds:
+			settings->MonitorIds = cnv.v;
+			break;
+
+		case FreeRDP_OrderSupport:
+			settings->OrderSupport = cnv.v;
+			break;
+
+		case FreeRDP_Password51:
+			settings->Password51 = cnv.v;
+			break;
+
+		case FreeRDP_RdpServerCertificate:
+			settings->RdpServerCertificate = cnv.v;
+			break;
+
+		case FreeRDP_RdpServerRsaKey:
+			settings->RdpServerRsaKey = cnv.v;
+			break;
+
+		case FreeRDP_ReceivedCapabilities:
+			settings->ReceivedCapabilities = cnv.v;
+			break;
+
+		case FreeRDP_ReceivedCapabilityData:
+			settings->ReceivedCapabilityData = cnv.v;
+			break;
+
+		case FreeRDP_ReceivedCapabilityDataSizes:
+			settings->ReceivedCapabilityDataSizes = cnv.v;
+			break;
+
+		case FreeRDP_RedirectionGuid:
+			settings->RedirectionGuid = cnv.v;
+			break;
+
+		case FreeRDP_RedirectionPassword:
+			settings->RedirectionPassword = cnv.v;
+			break;
+
+		case FreeRDP_RedirectionTargetCertificate:
+			settings->RedirectionTargetCertificate = cnv.v;
+			break;
+
+		case FreeRDP_RedirectionTsvUrl:
+			settings->RedirectionTsvUrl = cnv.v;
+			break;
+
+		case FreeRDP_ServerAutoReconnectCookie:
+			settings->ServerAutoReconnectCookie = cnv.v;
+			break;
+
+		case FreeRDP_ServerCertificate:
+			settings->ServerCertificate = cnv.v;
+			break;
+
+		case FreeRDP_ServerLicenseProductIssuers:
+			settings->ServerLicenseProductIssuers = cnv.v;
+			break;
+
+		case FreeRDP_ServerRandom:
+			settings->ServerRandom = cnv.v;
+			break;
+
+		case FreeRDP_StaticChannelArray:
+			settings->StaticChannelArray = cnv.v;
+			break;
+
+		case FreeRDP_TargetNetAddresses:
+			settings->TargetNetAddresses = cnv.v;
+			break;
+
+		case FreeRDP_TargetNetPorts:
+			settings->TargetNetPorts = cnv.v;
+			break;
+
+		case FreeRDP_instance:
+			settings->instance = cnv.v;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid key index %" PRIuz " [%s|%s]", id,
+			         freerdp_settings_get_name_for_key(id),
+			         freerdp_settings_get_type_name_for_key(id));
+			return FALSE;
+	}
+	return TRUE;
+}
diff --git a/libfreerdp/common/settings_str.c b/libfreerdp/common/settings_str.c
new file mode 100644
index 0000000..5072951
--- /dev/null
+++ b/libfreerdp/common/settings_str.c
@@ -0,0 +1,477 @@
+/* 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;
+	}
+}
diff --git a/libfreerdp/common/settings_str.h b/libfreerdp/common/settings_str.h
new file mode 100644
index 0000000..a3c71fb
--- /dev/null
+++ b/libfreerdp/common/settings_str.h
@@ -0,0 +1,612 @@
+/* Generated by  */
+
+#ifndef FREERDP_CORE_SETTINGS_STR_H
+#define FREERDP_CORE_SETTINGS_STR_H
+
+#include "../core/settings.h"
+
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("common.settings")
+
+typedef enum
+{
+	FREERDP_SETTINGS_TYPE_BOOL,
+	FREERDP_SETTINGS_TYPE_UINT16,
+	FREERDP_SETTINGS_TYPE_INT16,
+	FREERDP_SETTINGS_TYPE_UINT32,
+	FREERDP_SETTINGS_TYPE_INT32,
+	FREERDP_SETTINGS_TYPE_UINT64,
+	FREERDP_SETTINGS_TYPE_INT64,
+	FREERDP_SETTINGS_TYPE_STRING,
+	FREERDP_SETTINGS_TYPE_POINTER
+} FREERDP_SETTINGS_TYPE;
+
+struct settings_str_entry
+{
+	SSIZE_T id;
+	SSIZE_T type;
+	const char* str;
+};
+static const struct settings_str_entry settings_map[] = {
+	{ FreeRDP_AadSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AadSecurity" },
+	{ FreeRDP_AllowCacheWaitingList, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AllowCacheWaitingList" },
+	{ FreeRDP_AllowDesktopComposition, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AllowDesktopComposition" },
+	{ FreeRDP_AllowFontSmoothing, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AllowFontSmoothing" },
+	{ FreeRDP_AllowUnanouncedOrdersFromServer, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AllowUnanouncedOrdersFromServer" },
+	{ FreeRDP_AltSecFrameMarkerSupport, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AltSecFrameMarkerSupport" },
+	{ FreeRDP_AsyncChannels, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AsyncChannels" },
+	{ FreeRDP_AsyncUpdate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AsyncUpdate" },
+	{ FreeRDP_AudioCapture, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AudioCapture" },
+	{ FreeRDP_AudioPlayback, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AudioPlayback" },
+	{ FreeRDP_Authentication, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Authentication" },
+	{ FreeRDP_AuthenticationOnly, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AuthenticationOnly" },
+	{ FreeRDP_AutoAcceptCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoAcceptCertificate" },
+	{ FreeRDP_AutoDenyCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoDenyCertificate" },
+	{ FreeRDP_AutoLogonEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_AutoLogonEnabled" },
+	{ FreeRDP_AutoReconnectionEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_AutoReconnectionEnabled" },
+	{ FreeRDP_BitmapCacheEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_BitmapCacheEnabled" },
+	{ FreeRDP_BitmapCachePersistEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_BitmapCachePersistEnabled" },
+	{ FreeRDP_BitmapCacheV3Enabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_BitmapCacheV3Enabled" },
+	{ FreeRDP_BitmapCompressionDisabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_BitmapCompressionDisabled" },
+	{ FreeRDP_CertificateCallbackPreferPEM, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_CertificateCallbackPreferPEM" },
+	{ FreeRDP_CompressionEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_CompressionEnabled" },
+	{ FreeRDP_ConnectChildSession, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ConnectChildSession" },
+	{ FreeRDP_ConsoleSession, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ConsoleSession" },
+	{ FreeRDP_CredentialsFromStdin, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_CredentialsFromStdin" },
+	{ FreeRDP_DeactivateClientDecoding, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DeactivateClientDecoding" },
+	{ FreeRDP_Decorations, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Decorations" },
+	{ FreeRDP_DesktopResize, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DesktopResize" },
+	{ FreeRDP_DeviceRedirection, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DeviceRedirection" },
+	{ FreeRDP_DisableCredentialsDelegation, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DisableCredentialsDelegation" },
+	{ FreeRDP_DisableCtrlAltDel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCtrlAltDel" },
+	{ FreeRDP_DisableCursorBlinking, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCursorBlinking" },
+	{ FreeRDP_DisableCursorShadow, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableCursorShadow" },
+	{ FreeRDP_DisableFullWindowDrag, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableFullWindowDrag" },
+	{ FreeRDP_DisableMenuAnims, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableMenuAnims" },
+	{ FreeRDP_DisableRemoteAppCapsCheck, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DisableRemoteAppCapsCheck" },
+	{ FreeRDP_DisableThemes, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableThemes" },
+	{ FreeRDP_DisableWallpaper, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DisableWallpaper" },
+	{ FreeRDP_DrawAllowColorSubsampling, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawAllowColorSubsampling" },
+	{ FreeRDP_DrawAllowDynamicColorFidelity, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawAllowDynamicColorFidelity" },
+	{ FreeRDP_DrawAllowSkipAlpha, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawAllowSkipAlpha" },
+	{ FreeRDP_DrawGdiPlusCacheEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DrawGdiPlusCacheEnabled" },
+	{ FreeRDP_DrawGdiPlusEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawGdiPlusEnabled" },
+	{ FreeRDP_DrawNineGridEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DrawNineGridEnabled" },
+	{ FreeRDP_DumpRemoteFx, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_DumpRemoteFx" },
+	{ FreeRDP_DynamicDaylightTimeDisabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DynamicDaylightTimeDisabled" },
+	{ FreeRDP_DynamicResolutionUpdate, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_DynamicResolutionUpdate" },
+	{ FreeRDP_EmbeddedWindow, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EmbeddedWindow" },
+	{ FreeRDP_EnableWindowsKey, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EnableWindowsKey" },
+	{ FreeRDP_EncomspVirtualChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_EncomspVirtualChannel" },
+	{ FreeRDP_ExtSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ExtSecurity" },
+	{ FreeRDP_ExternalCertificateManagement, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_ExternalCertificateManagement" },
+	{ FreeRDP_FIPSMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FIPSMode" },
+	{ FreeRDP_FastPathInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FastPathInput" },
+	{ FreeRDP_FastPathOutput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_FastPathOutput" },
+	{ FreeRDP_ForceEncryptedCsPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ForceEncryptedCsPdu" },
+	{ FreeRDP_ForceMultimon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ForceMultimon" },
+	{ FreeRDP_FrameMarkerCommandEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_FrameMarkerCommandEnabled" },
+	{ FreeRDP_Fullscreen, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Fullscreen" },
+	{ FreeRDP_GatewayArmTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayArmTransport" },
+	{ FreeRDP_GatewayBypassLocal, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayBypassLocal" },
+	{ FreeRDP_GatewayEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayEnabled" },
+	{ FreeRDP_GatewayHttpExtAuthSspiNtlm, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayHttpExtAuthSspiNtlm" },
+	{ FreeRDP_GatewayHttpTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayHttpTransport" },
+	{ FreeRDP_GatewayHttpUseWebsockets, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayHttpUseWebsockets" },
+	{ FreeRDP_GatewayRpcTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayRpcTransport" },
+	{ FreeRDP_GatewayUdpTransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GatewayUdpTransport" },
+	{ FreeRDP_GatewayUseSameCredentials, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_GatewayUseSameCredentials" },
+	{ FreeRDP_GfxAVC444, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxAVC444" },
+	{ FreeRDP_GfxAVC444v2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxAVC444v2" },
+	{ FreeRDP_GfxH264, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxH264" },
+	{ FreeRDP_GfxPlanar, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxPlanar" },
+	{ FreeRDP_GfxProgressive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxProgressive" },
+	{ FreeRDP_GfxProgressiveV2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxProgressiveV2" },
+	{ FreeRDP_GfxSendQoeAck, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxSendQoeAck" },
+	{ FreeRDP_GfxSmallCache, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxSmallCache" },
+	{ FreeRDP_GfxThinClient, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GfxThinClient" },
+	{ FreeRDP_GrabKeyboard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GrabKeyboard" },
+	{ FreeRDP_GrabMouse, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_GrabMouse" },
+	{ FreeRDP_HasExtendedMouseEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasExtendedMouseEvent" },
+	{ FreeRDP_HasHorizontalWheel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasHorizontalWheel" },
+	{ FreeRDP_HasMonitorAttributes, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasMonitorAttributes" },
+	{ FreeRDP_HasQoeEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasQoeEvent" },
+	{ FreeRDP_HasRelativeMouseEvent, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HasRelativeMouseEvent" },
+	{ FreeRDP_HiDefRemoteApp, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_HiDefRemoteApp" },
+	{ FreeRDP_IPv6Enabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IPv6Enabled" },
+	{ FreeRDP_IgnoreCertificate, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IgnoreCertificate" },
+	{ FreeRDP_IgnoreInvalidDevices, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_IgnoreInvalidDevices" },
+	{ FreeRDP_JpegCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_JpegCodec" },
+	{ FreeRDP_KerberosRdgIsProxy, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_KerberosRdgIsProxy" },
+	{ FreeRDP_ListMonitors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ListMonitors" },
+	{ FreeRDP_LocalConnection, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LocalConnection" },
+	{ FreeRDP_LogonErrors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LogonErrors" },
+	{ FreeRDP_LogonNotify, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LogonNotify" },
+	{ FreeRDP_LongCredentialsSupported, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_LongCredentialsSupported" },
+	{ FreeRDP_LyncRdpMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_LyncRdpMode" },
+	{ FreeRDP_MaximizeShell, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MaximizeShell" },
+	{ FreeRDP_MouseAttached, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseAttached" },
+	{ FreeRDP_MouseHasWheel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseHasWheel" },
+	{ FreeRDP_MouseMotion, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseMotion" },
+	{ FreeRDP_MouseUseRelativeMove, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MouseUseRelativeMove" },
+	{ FreeRDP_MstscCookieMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MstscCookieMode" },
+	{ FreeRDP_MultiTouchGestures, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MultiTouchGestures" },
+	{ FreeRDP_MultiTouchInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_MultiTouchInput" },
+	{ FreeRDP_NSCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NSCodec" },
+	{ FreeRDP_NSCodecAllowDynamicColorFidelity, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NSCodecAllowDynamicColorFidelity" },
+	{ FreeRDP_NSCodecAllowSubsampling, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NSCodecAllowSubsampling" },
+	{ FreeRDP_NegotiateSecurityLayer, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NegotiateSecurityLayer" },
+	{ FreeRDP_NetworkAutoDetect, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NetworkAutoDetect" },
+	{ FreeRDP_NlaSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_NlaSecurity" },
+	{ FreeRDP_NoBitmapCompressionHeader, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_NoBitmapCompressionHeader" },
+	{ FreeRDP_OldLicenseBehaviour, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_OldLicenseBehaviour" },
+	{ FreeRDP_PasswordIsSmartcardPin, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_PasswordIsSmartcardPin" },
+	{ FreeRDP_PercentScreenUseHeight, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_PercentScreenUseHeight" },
+	{ FreeRDP_PercentScreenUseWidth, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PercentScreenUseWidth" },
+	{ FreeRDP_PlayRemoteFx, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PlayRemoteFx" },
+	{ FreeRDP_PreferIPv6OverIPv4, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PreferIPv6OverIPv4" },
+	{ FreeRDP_PrintReconnectCookie, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PrintReconnectCookie" },
+	{ FreeRDP_PromptForCredentials, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_PromptForCredentials" },
+	{ FreeRDP_RdpSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RdpSecurity" },
+	{ FreeRDP_RdstlsSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RdstlsSecurity" },
+	{ FreeRDP_RedirectClipboard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectClipboard" },
+	{ FreeRDP_RedirectDrives, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectDrives" },
+	{ FreeRDP_RedirectHomeDrive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectHomeDrive" },
+	{ FreeRDP_RedirectParallelPorts, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectParallelPorts" },
+	{ FreeRDP_RedirectPrinters, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectPrinters" },
+	{ FreeRDP_RedirectSerialPorts, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectSerialPorts" },
+	{ FreeRDP_RedirectSmartCards, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectSmartCards" },
+	{ FreeRDP_RedirectWebAuthN, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RedirectWebAuthN" },
+	{ FreeRDP_RefreshRect, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RefreshRect" },
+	{ FreeRDP_RemdeskVirtualChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemdeskVirtualChannel" },
+	{ FreeRDP_RemoteAppLanguageBarSupported, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RemoteAppLanguageBarSupported" },
+	{ FreeRDP_RemoteApplicationMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteApplicationMode" },
+	{ FreeRDP_RemoteAssistanceMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteAssistanceMode" },
+	{ FreeRDP_RemoteAssistanceRequestControl, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RemoteAssistanceRequestControl" },
+	{ FreeRDP_RemoteConsoleAudio, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteConsoleAudio" },
+	{ FreeRDP_RemoteCredentialGuard, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteCredentialGuard" },
+	{ FreeRDP_RemoteFxCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxCodec" },
+	{ FreeRDP_RemoteFxImageCodec, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxImageCodec" },
+	{ FreeRDP_RemoteFxOnly, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_RemoteFxOnly" },
+	{ FreeRDP_RestrictedAdminModeRequired, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_RestrictedAdminModeRequired" },
+	{ FreeRDP_SaltedChecksum, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SaltedChecksum" },
+	{ FreeRDP_SendPreconnectionPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SendPreconnectionPdu" },
+	{ FreeRDP_ServerLicenseRequired, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ServerLicenseRequired" },
+	{ FreeRDP_ServerMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ServerMode" },
+	{ FreeRDP_SmartSizing, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartSizing" },
+	{ FreeRDP_SmartcardEmulation, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartcardEmulation" },
+	{ FreeRDP_SmartcardLogon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SmartcardLogon" },
+	{ FreeRDP_SoftwareGdi, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SoftwareGdi" },
+	{ FreeRDP_SoundBeepsEnabled, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SoundBeepsEnabled" },
+	{ FreeRDP_SpanMonitors, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SpanMonitors" },
+	{ FreeRDP_SupportAsymetricKeys, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportAsymetricKeys" },
+	{ FreeRDP_SupportDisplayControl, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportDisplayControl" },
+	{ FreeRDP_SupportDynamicChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportDynamicChannels" },
+	{ FreeRDP_SupportDynamicTimeZone, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportDynamicTimeZone" },
+	{ FreeRDP_SupportEchoChannel, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEchoChannel" },
+	{ FreeRDP_SupportEdgeActionV1, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEdgeActionV1" },
+	{ FreeRDP_SupportEdgeActionV2, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportEdgeActionV2" },
+	{ FreeRDP_SupportErrorInfoPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportErrorInfoPdu" },
+	{ FreeRDP_SupportGeometryTracking, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportGeometryTracking" },
+	{ FreeRDP_SupportGraphicsPipeline, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportGraphicsPipeline" },
+	{ FreeRDP_SupportHeartbeatPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportHeartbeatPdu" },
+	{ FreeRDP_SupportMonitorLayoutPdu, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportMonitorLayoutPdu" },
+	{ FreeRDP_SupportMultitransport, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportMultitransport" },
+	{ FreeRDP_SupportSSHAgentChannel, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportSSHAgentChannel" },
+	{ FreeRDP_SupportSkipChannelJoin, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SupportSkipChannelJoin" },
+	{ FreeRDP_SupportStatusInfoPdu, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportStatusInfoPdu" },
+	{ FreeRDP_SupportVideoOptimized, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SupportVideoOptimized" },
+	{ FreeRDP_SuppressOutput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SuppressOutput" },
+	{ FreeRDP_SurfaceCommandsEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SurfaceCommandsEnabled" },
+	{ FreeRDP_SurfaceFrameMarkerEnabled, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SurfaceFrameMarkerEnabled" },
+	{ FreeRDP_SuspendInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_SuspendInput" },
+	{ FreeRDP_SynchronousDynamicChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SynchronousDynamicChannels" },
+	{ FreeRDP_SynchronousStaticChannels, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_SynchronousStaticChannels" },
+	{ FreeRDP_TcpKeepAlive, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TcpKeepAlive" },
+	{ FreeRDP_TlsSecurity, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TlsSecurity" },
+	{ FreeRDP_ToggleFullscreen, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_ToggleFullscreen" },
+	{ FreeRDP_TransportDump, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TransportDump" },
+	{ FreeRDP_TransportDumpReplay, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_TransportDumpReplay" },
+	{ FreeRDP_UnicodeInput, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UnicodeInput" },
+	{ FreeRDP_UnmapButtons, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UnmapButtons" },
+	{ FreeRDP_UseCommonStdioCallbacks, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_UseCommonStdioCallbacks" },
+	{ FreeRDP_UseMultimon, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UseMultimon" },
+	{ FreeRDP_UseRdpSecurityLayer, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UseRdpSecurityLayer" },
+	{ FreeRDP_UsingSavedCredentials, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_UsingSavedCredentials" },
+	{ FreeRDP_VideoDisable, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_VideoDisable" },
+	{ FreeRDP_VmConnectMode, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_VmConnectMode" },
+	{ FreeRDP_WaitForOutputBufferFlush, FREERDP_SETTINGS_TYPE_BOOL,
+	  "FreeRDP_WaitForOutputBufferFlush" },
+	{ FreeRDP_Workarea, FREERDP_SETTINGS_TYPE_BOOL, "FreeRDP_Workarea" },
+	{ FreeRDP_CapsGeneralCompressionLevel, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsGeneralCompressionLevel" },
+	{ FreeRDP_CapsGeneralCompressionTypes, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsGeneralCompressionTypes" },
+	{ FreeRDP_CapsProtocolVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_CapsProtocolVersion" },
+	{ FreeRDP_CapsRemoteUnshareFlag, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsRemoteUnshareFlag" },
+	{ FreeRDP_CapsUpdateCapabilityFlag, FREERDP_SETTINGS_TYPE_UINT16,
+	  "FreeRDP_CapsUpdateCapabilityFlag" },
+	{ FreeRDP_DesktopOrientation, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_DesktopOrientation" },
+	{ FreeRDP_OrderSupportFlags, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_OrderSupportFlags" },
+	{ FreeRDP_OrderSupportFlagsEx, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_OrderSupportFlagsEx" },
+	{ FreeRDP_ProxyPort, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_ProxyPort" },
+	{ FreeRDP_SupportedColorDepths, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_SupportedColorDepths" },
+	{ FreeRDP_TLSMaxVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TLSMaxVersion" },
+	{ FreeRDP_TLSMinVersion, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TLSMinVersion" },
+	{ FreeRDP_TextANSICodePage, FREERDP_SETTINGS_TYPE_UINT16, "FreeRDP_TextANSICodePage" },
+	{ FreeRDP_AcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_AcceptedCertLength" },
+	{ FreeRDP_AuthenticationLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_AuthenticationLevel" },
+	{ FreeRDP_AutoReconnectMaxRetries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_AutoReconnectMaxRetries" },
+	{ FreeRDP_BitmapCacheV2NumCells, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_BitmapCacheV2NumCells" },
+	{ FreeRDP_BitmapCacheV3CodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BitmapCacheV3CodecId" },
+	{ FreeRDP_BitmapCacheVersion, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BitmapCacheVersion" },
+	{ FreeRDP_BrushSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_BrushSupportLevel" },
+	{ FreeRDP_ChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ChannelCount" },
+	{ FreeRDP_ChannelDefArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ChannelDefArraySize" },
+	{ FreeRDP_ClientBuild, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientBuild" },
+	{ FreeRDP_ClientRandomLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientRandomLength" },
+	{ FreeRDP_ClientSessionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClientSessionId" },
+	{ FreeRDP_ClipboardFeatureMask, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClipboardFeatureMask" },
+	{ FreeRDP_ClusterInfoFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ClusterInfoFlags" },
+	{ FreeRDP_ColorDepth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ColorDepth" },
+	{ FreeRDP_ColorPointerCacheSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ColorPointerCacheSize" },
+	{ FreeRDP_CompDeskSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CompDeskSupportLevel" },
+	{ FreeRDP_CompressionLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CompressionLevel" },
+	{ FreeRDP_ConnectionType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ConnectionType" },
+	{ FreeRDP_CookieMaxLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_CookieMaxLength" },
+	{ FreeRDP_DesktopHeight, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopHeight" },
+	{ FreeRDP_DesktopPhysicalHeight, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DesktopPhysicalHeight" },
+	{ FreeRDP_DesktopPhysicalWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPhysicalWidth" },
+	{ FreeRDP_DesktopPosX, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPosX" },
+	{ FreeRDP_DesktopPosY, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopPosY" },
+	{ FreeRDP_DesktopScaleFactor, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopScaleFactor" },
+	{ FreeRDP_DesktopWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DesktopWidth" },
+	{ FreeRDP_DeviceArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceArraySize" },
+	{ FreeRDP_DeviceCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceCount" },
+	{ FreeRDP_DeviceScaleFactor, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DeviceScaleFactor" },
+	{ FreeRDP_DrawNineGridCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DrawNineGridCacheEntries" },
+	{ FreeRDP_DrawNineGridCacheSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DrawNineGridCacheSize" },
+	{ FreeRDP_DynamicChannelArraySize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_DynamicChannelArraySize" },
+	{ FreeRDP_DynamicChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_DynamicChannelCount" },
+	{ FreeRDP_EarlyCapabilityFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EarlyCapabilityFlags" },
+	{ FreeRDP_EncryptionLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EncryptionLevel" },
+	{ FreeRDP_EncryptionMethods, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_EncryptionMethods" },
+	{ FreeRDP_ExtEncryptionMethods, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ExtEncryptionMethods" },
+	{ FreeRDP_FakeMouseMotionInterval, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_FakeMouseMotionInterval" },
+	{ FreeRDP_Floatbar, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_Floatbar" },
+	{ FreeRDP_FrameAcknowledge, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_FrameAcknowledge" },
+	{ FreeRDP_GatewayAcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_GatewayAcceptedCertLength" },
+	{ FreeRDP_GatewayCredentialsSource, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_GatewayCredentialsSource" },
+	{ FreeRDP_GatewayPort, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GatewayPort" },
+	{ FreeRDP_GatewayUsageMethod, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GatewayUsageMethod" },
+	{ FreeRDP_GfxCapsFilter, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GfxCapsFilter" },
+	{ FreeRDP_GlyphSupportLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_GlyphSupportLevel" },
+	{ FreeRDP_JpegCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_JpegCodecId" },
+	{ FreeRDP_JpegQuality, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_JpegQuality" },
+	{ FreeRDP_KeySpec, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeySpec" },
+	{ FreeRDP_KeyboardCodePage, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardCodePage" },
+	{ FreeRDP_KeyboardFunctionKey, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardFunctionKey" },
+	{ FreeRDP_KeyboardHook, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardHook" },
+	{ FreeRDP_KeyboardLayout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardLayout" },
+	{ FreeRDP_KeyboardSubType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardSubType" },
+	{ FreeRDP_KeyboardType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_KeyboardType" },
+	{ FreeRDP_LargePointerFlag, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_LargePointerFlag" },
+	{ FreeRDP_LoadBalanceInfoLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_LoadBalanceInfoLength" },
+	{ FreeRDP_MonitorAttributeFlags, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_MonitorAttributeFlags" },
+	{ FreeRDP_MonitorCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorCount" },
+	{ FreeRDP_MonitorDefArraySize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorDefArraySize" },
+	{ FreeRDP_MonitorFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorFlags" },
+	{ FreeRDP_MonitorLocalShiftX, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorLocalShiftX" },
+	{ FreeRDP_MonitorLocalShiftY, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MonitorLocalShiftY" },
+	{ FreeRDP_MultifragMaxRequestSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_MultifragMaxRequestSize" },
+	{ FreeRDP_MultitransportFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_MultitransportFlags" },
+	{ FreeRDP_NSCodecColorLossLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_NSCodecColorLossLevel" },
+	{ FreeRDP_NSCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NSCodecId" },
+	{ FreeRDP_NegotiationFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NegotiationFlags" },
+	{ FreeRDP_NumMonitorIds, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_NumMonitorIds" },
+	{ FreeRDP_OffscreenCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_OffscreenCacheEntries" },
+	{ FreeRDP_OffscreenCacheSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OffscreenCacheSize" },
+	{ FreeRDP_OffscreenSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_OffscreenSupportLevel" },
+	{ FreeRDP_OsMajorType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OsMajorType" },
+	{ FreeRDP_OsMinorType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_OsMinorType" },
+	{ FreeRDP_Password51Length, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_Password51Length" },
+	{ FreeRDP_PduSource, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PduSource" },
+	{ FreeRDP_PercentScreen, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PercentScreen" },
+	{ FreeRDP_PerformanceFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PerformanceFlags" },
+	{ FreeRDP_PointerCacheSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PointerCacheSize" },
+	{ FreeRDP_PreconnectionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_PreconnectionId" },
+	{ FreeRDP_ProxyType, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ProxyType" },
+	{ FreeRDP_RdpVersion, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RdpVersion" },
+	{ FreeRDP_ReceivedCapabilitiesSize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ReceivedCapabilitiesSize" },
+	{ FreeRDP_RedirectedSessionId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RedirectedSessionId" },
+	{ FreeRDP_RedirectionAcceptedCertLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionAcceptedCertLength" },
+	{ FreeRDP_RedirectionFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RedirectionFlags" },
+	{ FreeRDP_RedirectionGuidLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionGuidLength" },
+	{ FreeRDP_RedirectionPasswordLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionPasswordLength" },
+	{ FreeRDP_RedirectionPreferType, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionPreferType" },
+	{ FreeRDP_RedirectionTsvUrlLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RedirectionTsvUrlLength" },
+	{ FreeRDP_RemoteAppNumIconCacheEntries, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteAppNumIconCacheEntries" },
+	{ FreeRDP_RemoteAppNumIconCaches, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteAppNumIconCaches" },
+	{ FreeRDP_RemoteApplicationExpandCmdLine, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationExpandCmdLine" },
+	{ FreeRDP_RemoteApplicationExpandWorkingDir, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationExpandWorkingDir" },
+	{ FreeRDP_RemoteApplicationSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationSupportLevel" },
+	{ FreeRDP_RemoteApplicationSupportMask, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteApplicationSupportMask" },
+	{ FreeRDP_RemoteFxCaptureFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCaptureFlags" },
+	{ FreeRDP_RemoteFxCodecId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCodecId" },
+	{ FreeRDP_RemoteFxCodecMode, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RemoteFxCodecMode" },
+	{ FreeRDP_RemoteWndSupportLevel, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_RemoteWndSupportLevel" },
+	{ FreeRDP_RequestedProtocols, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_RequestedProtocols" },
+	{ FreeRDP_SelectedProtocol, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SelectedProtocol" },
+	{ FreeRDP_ServerCertificateLength, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerCertificateLength" },
+	{ FreeRDP_ServerLicenseProductIssuersCount, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerLicenseProductIssuersCount" },
+	{ FreeRDP_ServerLicenseProductVersion, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_ServerLicenseProductVersion" },
+	{ FreeRDP_ServerPort, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ServerPort" },
+	{ FreeRDP_ServerRandomLength, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ServerRandomLength" },
+	{ FreeRDP_ShareId, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ShareId" },
+	{ FreeRDP_SmartSizingHeight, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SmartSizingHeight" },
+	{ FreeRDP_SmartSizingWidth, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_SmartSizingWidth" },
+	{ FreeRDP_StaticChannelArraySize, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_StaticChannelArraySize" },
+	{ FreeRDP_StaticChannelCount, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_StaticChannelCount" },
+	{ FreeRDP_TargetNetAddressCount, FREERDP_SETTINGS_TYPE_UINT32,
+	  "FreeRDP_TargetNetAddressCount" },
+	{ FreeRDP_TcpAckTimeout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpAckTimeout" },
+	{ FreeRDP_TcpConnectTimeout, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpConnectTimeout" },
+	{ FreeRDP_TcpKeepAliveDelay, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveDelay" },
+	{ FreeRDP_TcpKeepAliveInterval, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveInterval" },
+	{ FreeRDP_TcpKeepAliveRetries, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TcpKeepAliveRetries" },
+	{ FreeRDP_ThreadingFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_ThreadingFlags" },
+	{ FreeRDP_TlsSecLevel, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_TlsSecLevel" },
+	{ FreeRDP_VCChunkSize, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_VCChunkSize" },
+	{ FreeRDP_VCFlags, FREERDP_SETTINGS_TYPE_UINT32, "FreeRDP_VCFlags" },
+	{ FreeRDP_XPan, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_XPan" },
+	{ FreeRDP_YPan, FREERDP_SETTINGS_TYPE_INT32, "FreeRDP_YPan" },
+	{ FreeRDP_ParentWindowId, FREERDP_SETTINGS_TYPE_UINT64, "FreeRDP_ParentWindowId" },
+	{ FreeRDP_AadServerHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AadServerHostname" },
+	{ FreeRDP_AcceptedCert, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AcceptedCert" },
+	{ FreeRDP_ActionScript, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ActionScript" },
+	{ FreeRDP_AllowedTlsCiphers, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AllowedTlsCiphers" },
+	{ FreeRDP_AlternateShell, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AlternateShell" },
+	{ FreeRDP_AssistanceFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_AssistanceFile" },
+	{ FreeRDP_AuthenticationPackageList, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_AuthenticationPackageList" },
+	{ FreeRDP_AuthenticationServiceClass, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_AuthenticationServiceClass" },
+	{ FreeRDP_BitmapCachePersistFile, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_BitmapCachePersistFile" },
+	{ FreeRDP_CardName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CardName" },
+	{ FreeRDP_CertificateAcceptedFingerprints, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_CertificateAcceptedFingerprints" },
+	{ FreeRDP_CertificateName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CertificateName" },
+	{ FreeRDP_ClientAddress, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientAddress" },
+	{ FreeRDP_ClientDir, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientDir" },
+	{ FreeRDP_ClientHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientHostname" },
+	{ FreeRDP_ClientProductId, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ClientProductId" },
+	{ FreeRDP_ClipboardUseSelection, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ClipboardUseSelection" },
+	{ FreeRDP_ComputerName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ComputerName" },
+	{ FreeRDP_ConfigPath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ConfigPath" },
+	{ FreeRDP_ConnectionFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ConnectionFile" },
+	{ FreeRDP_ContainerName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ContainerName" },
+	{ FreeRDP_CspName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CspName" },
+	{ FreeRDP_CurrentPath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_CurrentPath" },
+	{ FreeRDP_Domain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Domain" },
+	{ FreeRDP_DrivesToRedirect, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_DrivesToRedirect" },
+	{ FreeRDP_DumpRemoteFxFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_DumpRemoteFxFile" },
+	{ FreeRDP_DynamicDSTTimeZoneKeyName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_DynamicDSTTimeZoneKeyName" },
+	{ FreeRDP_GatewayAcceptedCert, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAcceptedCert" },
+	{ FreeRDP_GatewayAccessToken, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAccessToken" },
+	{ FreeRDP_GatewayAvdAadtenantid, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdAadtenantid" },
+	{ FreeRDP_GatewayAvdActivityhint, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdActivityhint" },
+	{ FreeRDP_GatewayAvdArmpath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAvdArmpath" },
+	{ FreeRDP_GatewayAvdDiagnosticserviceurl, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdDiagnosticserviceurl" },
+	{ FreeRDP_GatewayAvdGeo, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayAvdGeo" },
+	{ FreeRDP_GatewayAvdHubdiscoverygeourl, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdHubdiscoverygeourl" },
+	{ FreeRDP_GatewayAvdWvdEndpointPool, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayAvdWvdEndpointPool" },
+	{ FreeRDP_GatewayDomain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayDomain" },
+	{ FreeRDP_GatewayHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayHostname" },
+	{ FreeRDP_GatewayHttpExtAuthBearer, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_GatewayHttpExtAuthBearer" },
+	{ FreeRDP_GatewayPassword, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayPassword" },
+	{ FreeRDP_GatewayUrl, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayUrl" },
+	{ FreeRDP_GatewayUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_GatewayUsername" },
+	{ FreeRDP_HomePath, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_HomePath" },
+	{ FreeRDP_ImeFileName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ImeFileName" },
+	{ FreeRDP_KerberosArmor, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosArmor" },
+	{ FreeRDP_KerberosCache, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosCache" },
+	{ FreeRDP_KerberosKdcUrl, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosKdcUrl" },
+	{ FreeRDP_KerberosKeytab, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosKeytab" },
+	{ FreeRDP_KerberosLifeTime, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosLifeTime" },
+	{ FreeRDP_KerberosRealm, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosRealm" },
+	{ FreeRDP_KerberosRenewableLifeTime, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_KerberosRenewableLifeTime" },
+	{ FreeRDP_KerberosStartTime, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KerberosStartTime" },
+	{ FreeRDP_KeyboardPipeName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_KeyboardPipeName" },
+	{ FreeRDP_KeyboardRemappingList, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_KeyboardRemappingList" },
+	{ FreeRDP_NtlmSamFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_NtlmSamFile" },
+	{ FreeRDP_Password, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Password" },
+	{ FreeRDP_PasswordHash, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PasswordHash" },
+	{ FreeRDP_Pkcs11Module, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Pkcs11Module" },
+	{ FreeRDP_PkinitAnchors, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PkinitAnchors" },
+	{ FreeRDP_PlayRemoteFxFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PlayRemoteFxFile" },
+	{ FreeRDP_PreconnectionBlob, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_PreconnectionBlob" },
+	{ FreeRDP_ProxyHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyHostname" },
+	{ FreeRDP_ProxyPassword, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyPassword" },
+	{ FreeRDP_ProxyUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ProxyUsername" },
+	{ FreeRDP_RDP2TCPArgs, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RDP2TCPArgs" },
+	{ FreeRDP_ReaderName, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ReaderName" },
+	{ FreeRDP_RedirectionAcceptedCert, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionAcceptedCert" },
+	{ FreeRDP_RedirectionDomain, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RedirectionDomain" },
+	{ FreeRDP_RedirectionTargetFQDN, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionTargetFQDN" },
+	{ FreeRDP_RedirectionTargetNetBiosName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RedirectionTargetNetBiosName" },
+	{ FreeRDP_RedirectionUsername, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_RedirectionUsername" },
+	{ FreeRDP_RemoteApplicationCmdLine, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationCmdLine" },
+	{ FreeRDP_RemoteApplicationFile, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationFile" },
+	{ FreeRDP_RemoteApplicationGuid, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationGuid" },
+	{ FreeRDP_RemoteApplicationIcon, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationIcon" },
+	{ FreeRDP_RemoteApplicationName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationName" },
+	{ FreeRDP_RemoteApplicationProgram, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationProgram" },
+	{ FreeRDP_RemoteApplicationWorkingDir, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteApplicationWorkingDir" },
+	{ FreeRDP_RemoteAssistancePassStub, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistancePassStub" },
+	{ FreeRDP_RemoteAssistancePassword, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistancePassword" },
+	{ FreeRDP_RemoteAssistanceRCTicket, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistanceRCTicket" },
+	{ FreeRDP_RemoteAssistanceSessionId, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_RemoteAssistanceSessionId" },
+	{ FreeRDP_ServerHostname, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_ServerHostname" },
+	{ FreeRDP_ServerLicenseCompanyName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ServerLicenseCompanyName" },
+	{ FreeRDP_ServerLicenseProductName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ServerLicenseProductName" },
+	{ FreeRDP_ShellWorkingDirectory, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_ShellWorkingDirectory" },
+	{ FreeRDP_SmartcardCertificate, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SmartcardCertificate" },
+	{ FreeRDP_SmartcardPrivateKey, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SmartcardPrivateKey" },
+	{ FreeRDP_SspiModule, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_SspiModule" },
+	{ FreeRDP_TargetNetAddress, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TargetNetAddress" },
+	{ FreeRDP_TerminalDescriptor, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TerminalDescriptor" },
+	{ FreeRDP_TlsSecretsFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TlsSecretsFile" },
+	{ FreeRDP_TransportDumpFile, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_TransportDumpFile" },
+	{ FreeRDP_UserSpecifiedServerName, FREERDP_SETTINGS_TYPE_STRING,
+	  "FreeRDP_UserSpecifiedServerName" },
+	{ FreeRDP_Username, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_Username" },
+	{ FreeRDP_WinSCardModule, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WinSCardModule" },
+	{ FreeRDP_WindowTitle, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WindowTitle" },
+	{ FreeRDP_WmClass, FREERDP_SETTINGS_TYPE_STRING, "FreeRDP_WmClass" },
+	{ FreeRDP_BitmapCacheV2CellInfo, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_BitmapCacheV2CellInfo" },
+	{ FreeRDP_ChannelDefArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ChannelDefArray" },
+	{ FreeRDP_ClientAutoReconnectCookie, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ClientAutoReconnectCookie" },
+	{ FreeRDP_ClientRandom, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ClientRandom" },
+	{ FreeRDP_ClientTimeZone, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ClientTimeZone" },
+	{ FreeRDP_DeviceArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_DeviceArray" },
+	{ FreeRDP_DynamicChannelArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_DynamicChannelArray" },
+	{ FreeRDP_FragCache, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_FragCache" },
+	{ FreeRDP_GlyphCache, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_GlyphCache" },
+	{ FreeRDP_LoadBalanceInfo, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_LoadBalanceInfo" },
+	{ FreeRDP_MonitorDefArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_MonitorDefArray" },
+	{ FreeRDP_MonitorIds, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_MonitorIds" },
+	{ FreeRDP_OrderSupport, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_OrderSupport" },
+	{ FreeRDP_Password51, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_Password51" },
+	{ FreeRDP_RdpServerCertificate, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RdpServerCertificate" },
+	{ FreeRDP_RdpServerRsaKey, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RdpServerRsaKey" },
+	{ FreeRDP_ReceivedCapabilities, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ReceivedCapabilities" },
+	{ FreeRDP_ReceivedCapabilityData, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ReceivedCapabilityData" },
+	{ FreeRDP_ReceivedCapabilityDataSizes, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ReceivedCapabilityDataSizes" },
+	{ FreeRDP_RedirectionGuid, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionGuid" },
+	{ FreeRDP_RedirectionPassword, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionPassword" },
+	{ FreeRDP_RedirectionTargetCertificate, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_RedirectionTargetCertificate" },
+	{ FreeRDP_RedirectionTsvUrl, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_RedirectionTsvUrl" },
+	{ FreeRDP_ServerAutoReconnectCookie, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ServerAutoReconnectCookie" },
+	{ FreeRDP_ServerCertificate, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ServerCertificate" },
+	{ FreeRDP_ServerLicenseProductIssuers, FREERDP_SETTINGS_TYPE_POINTER,
+	  "FreeRDP_ServerLicenseProductIssuers" },
+	{ FreeRDP_ServerRandom, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_ServerRandom" },
+	{ FreeRDP_StaticChannelArray, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_StaticChannelArray" },
+	{ FreeRDP_TargetNetAddresses, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_TargetNetAddresses" },
+	{ FreeRDP_TargetNetPorts, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_TargetNetPorts" },
+	{ FreeRDP_instance, FREERDP_SETTINGS_TYPE_POINTER, "FreeRDP_instance" },
+};
+
+#endif
diff --git a/libfreerdp/common/test/CMakeLists.txt b/libfreerdp/common/test/CMakeLists.txt
new file mode 100644
index 0000000..c1f871b
--- /dev/null
+++ b/libfreerdp/common/test/CMakeLists.txt
@@ -0,0 +1,44 @@
+
+set(MODULE_NAME "TestCommon")
+set(MODULE_PREFIX "TEST_COMMON")
+
+set(${MODULE_PREFIX}_DRIVER ${MODULE_NAME}.c)
+
+set(${MODULE_PREFIX}_TESTS
+    TestAddinArgv.c
+	TestCommonAssistance.c)
+
+set(${MODULE_PREFIX}_FUZZERS
+	TestFuzzCommonAssistanceParseFileBuffer.c
+	TestFuzzCommonAssistanceBinToHexString.c
+	TestFuzzCommonAssistanceHexStringToBin.c)
+
+create_test_sourcelist(${MODULE_PREFIX}_SRCS
+	${${MODULE_PREFIX}_DRIVER}
+	${${MODULE_PREFIX}_TESTS})
+
+add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS})
+
+target_link_libraries(${MODULE_NAME} freerdp winpr)
+
+if (BUILD_FUZZERS)
+	foreach(test ${${MODULE_PREFIX}_FUZZERS})
+		get_filename_component(TestName ${test} NAME_WE)
+		add_executable(${TestName} ${test})
+		# Use PUBLIC to force 'fuzzer_config' for all dependent targets.
+		target_link_libraries(${TestName} PUBLIC freerdp winpr fuzzer_config)
+		add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
+		set_target_properties(${TestName} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
+		add_dependencies(fuzzers ${TestName})
+	endforeach()
+endif (BUILD_FUZZERS)
+
+set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
+
+foreach(test ${${MODULE_PREFIX}_TESTS})
+	get_filename_component(TestName ${test} NAME_WE)
+	add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
+endforeach()
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "FreeRDP/Common/Test")
+
diff --git a/libfreerdp/common/test/TestAddinArgv.c b/libfreerdp/common/test/TestAddinArgv.c
new file mode 100644
index 0000000..f9a1f8b
--- /dev/null
+++ b/libfreerdp/common/test/TestAddinArgv.c
@@ -0,0 +1,345 @@
+#include <winpr/crt.h>
+#include <winpr/crypto.h>
+
+#include <freerdp/settings.h>
+
+static BOOL test_alloc(void)
+{
+	BOOL rc = FALSE;
+	int rng = 0;
+	const char* param[] = { "foo:", "bar", "bla", "rdp", NULL };
+	ADDIN_ARGV* arg1 = NULL;
+	ADDIN_ARGV* arg2 = NULL;
+	ADDIN_ARGV* arg3 = NULL;
+	ADDIN_ARGV* arg4 = NULL;
+
+	/* Test empty allocation */
+	arg1 = freerdp_addin_argv_new(0, NULL);
+	if (!arg1 || (arg1->argc != 0) || (arg1->argv))
+		goto fail;
+
+	/* Test allocation without initializing arguments of random size > 0 */
+	winpr_RAND(&rng, sizeof(rng));
+	rng = abs(rng % 8192) + 1;
+
+	arg2 = freerdp_addin_argv_new(rng, NULL);
+	if (!arg2 || (arg2->argc != rng) || (!arg2->argv))
+		goto fail;
+	for (int x = 0; x < arg2->argc; x++)
+	{
+		if (arg2->argv[x])
+			goto fail;
+	}
+
+	/* Test allocation with initializing arguments of size > 0 */
+	arg3 = freerdp_addin_argv_new(ARRAYSIZE(param) - 1, param);
+	if (!arg3 || (arg3->argc != ARRAYSIZE(param) - 1) || (!arg3->argv))
+		goto fail;
+
+	for (int x = 0; x < arg3->argc; x++)
+	{
+		if (strcmp(arg3->argv[x], param[x]) != 0)
+			goto fail;
+	}
+
+	/* Input lists with NULL elements are not allowed */
+	arg4 = freerdp_addin_argv_new(ARRAYSIZE(param), param);
+	if (arg4)
+		goto fail;
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg1);
+	freerdp_addin_argv_free(arg2);
+	freerdp_addin_argv_free(arg3);
+	freerdp_addin_argv_free(arg4);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_clone(void)
+{
+	BOOL rc = FALSE;
+	const char* param[] = { "foo:", "bar", "bla", "rdp" };
+	ADDIN_ARGV* arg = NULL;
+	ADDIN_ARGV* clone = NULL;
+	ADDIN_ARGV* clone2 = NULL;
+
+	arg = freerdp_addin_argv_new(ARRAYSIZE(param), param);
+	if (!arg || (arg->argc != ARRAYSIZE(param)))
+		goto fail;
+	clone = freerdp_addin_argv_clone(arg);
+	if (!clone || (clone->argc != arg->argc))
+		goto fail;
+
+	for (int x = 0; x < arg->argc; x++)
+	{
+		if (strcmp(param[x], arg->argv[x]) != 0)
+			goto fail;
+		if (strcmp(param[x], clone->argv[x]) != 0)
+			goto fail;
+	}
+
+	clone2 = freerdp_addin_argv_clone(NULL);
+	if (clone2)
+		goto fail;
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	freerdp_addin_argv_free(clone);
+	freerdp_addin_argv_free(clone2);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_add_remove(void)
+{
+	const char* args[] = { "foo", "bar", "bla", "gaga" };
+	BOOL rc = FALSE;
+	ADDIN_ARGV* arg = freerdp_addin_argv_new(0, NULL);
+
+	if (!arg || (arg->argc != 0) || arg->argv)
+		goto fail;
+	for (size_t y = 0; y < ARRAYSIZE(args); y++)
+	{
+		const char* param = args[y];
+		if (!freerdp_addin_argv_add_argument(arg, param))
+			goto fail;
+		if (arg->argc != (int)y + 1)
+			goto fail;
+		if (!arg->argv)
+			goto fail;
+		if (strcmp(arg->argv[y], param) != 0)
+			goto fail;
+	}
+
+	/* Try to remove non existing element, must not return TRUE */
+	if (freerdp_addin_argv_del_argument(arg, "foobar"))
+		goto fail;
+
+	/* Invalid parameters, must return FALSE */
+	if (freerdp_addin_argv_del_argument(NULL, "foobar"))
+		goto fail;
+
+	/* Invalid parameters, must return FALSE */
+	if (freerdp_addin_argv_del_argument(arg, NULL))
+		goto fail;
+
+	/* Remove elements one by one to test argument index move */
+	for (size_t y = 0; y < ARRAYSIZE(args); y++)
+	{
+		const char* param = args[y];
+		if (!freerdp_addin_argv_del_argument(arg, param))
+			goto fail;
+		for (size_t x = y + 1; x < ARRAYSIZE(args); x++)
+		{
+			if (strcmp(arg->argv[x - y - 1], args[x]) != 0)
+				goto fail;
+		}
+	}
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_set_argument(void)
+{
+	int ret = 0;
+	const char* newarg = "foobar";
+	const char* args[] = { "foo", "bar", "bla", "gaga" };
+	BOOL rc = FALSE;
+	ADDIN_ARGV* arg = NULL;
+
+	arg = freerdp_addin_argv_new(ARRAYSIZE(args), args);
+	if (!arg || (arg->argc != ARRAYSIZE(args)) || !arg->argv)
+		goto fail;
+
+	/* Check invalid parameters */
+	ret = freerdp_addin_set_argument(NULL, "foo");
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_set_argument(arg, NULL);
+	if (ret >= 0)
+		goto fail;
+
+	/* Try existing parameter */
+	ret = freerdp_addin_set_argument(arg, "foo");
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)))
+		goto fail;
+
+	/* Try new parameter */
+	ret = freerdp_addin_set_argument(arg, newarg);
+	if ((ret != 0) || (arg->argc != ARRAYSIZE(args) + 1) ||
+	    (strcmp(newarg, arg->argv[ARRAYSIZE(args)]) != 0))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_replace_argument(void)
+{
+	int ret = 0;
+	const char* newarg = "foobar";
+	const char* args[] = { "foo", "bar", "bla", "gaga" };
+	BOOL rc = FALSE;
+	ADDIN_ARGV* arg = NULL;
+
+	arg = freerdp_addin_argv_new(ARRAYSIZE(args), args);
+	if (!arg || (arg->argc != ARRAYSIZE(args)) || !arg->argv)
+		goto fail;
+
+	/* Check invalid parameters */
+	ret = freerdp_addin_replace_argument(NULL, "foo", newarg);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_replace_argument(arg, NULL, newarg);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_replace_argument(arg, "foo", NULL);
+	if (ret >= 0)
+		goto fail;
+
+	/* Try existing parameter */
+	ret = freerdp_addin_replace_argument(arg, "foo", newarg);
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)) || (strcmp(arg->argv[0], newarg) != 0))
+		goto fail;
+
+	/* Try new parameter */
+	ret = freerdp_addin_replace_argument(arg, "lalala", newarg);
+	if ((ret != 0) || (arg->argc != ARRAYSIZE(args) + 1) ||
+	    (strcmp(newarg, arg->argv[ARRAYSIZE(args)]) != 0))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_set_argument_value(void)
+{
+	int ret = 0;
+	const char* newarg1 = "foobar";
+	const char* newarg2 = "lalala";
+	const char* fullnewarg1 = "foo:foobar";
+	const char* fullnewarg2 = "foo:lalala";
+	const char* fullnewvalue = "lalala:foobar";
+	const char* args[] = { "foo", "foo:", "bar", "bla", "gaga" };
+	BOOL rc = FALSE;
+	ADDIN_ARGV* arg = NULL;
+
+	arg = freerdp_addin_argv_new(ARRAYSIZE(args), args);
+	if (!arg || (arg->argc != ARRAYSIZE(args)) || !arg->argv)
+		goto fail;
+
+	/* Check invalid parameters */
+	ret = freerdp_addin_set_argument_value(NULL, "foo", newarg1);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_set_argument_value(arg, NULL, newarg1);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_set_argument_value(arg, "foo", NULL);
+	if (ret >= 0)
+		goto fail;
+
+	/* Try existing parameter */
+	ret = freerdp_addin_set_argument_value(arg, "foo", newarg1);
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)) || (strcmp(arg->argv[1], fullnewarg1) != 0))
+		goto fail;
+	ret = freerdp_addin_set_argument_value(arg, "foo", newarg2);
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)) || (strcmp(arg->argv[1], fullnewarg2) != 0))
+		goto fail;
+
+	/* Try new parameter */
+	ret = freerdp_addin_set_argument_value(arg, newarg2, newarg1);
+	if ((ret != 0) || (arg->argc != ARRAYSIZE(args) + 1) ||
+	    (strcmp(fullnewvalue, arg->argv[ARRAYSIZE(args)]) != 0))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+static BOOL test_replace_argument_value(void)
+{
+	int ret = 0;
+	const char* newarg1 = "foobar";
+	const char* newarg2 = "lalala";
+	const char* fullnewarg1 = "foo:foobar";
+	const char* fullnewarg2 = "foo:lalala";
+	const char* fullnewvalue = "lalala:foobar";
+	const char* args[] = { "foo", "foo:", "bar", "bla", "gaga" };
+	BOOL rc = FALSE;
+	ADDIN_ARGV* arg = NULL;
+
+	arg = freerdp_addin_argv_new(ARRAYSIZE(args), args);
+	if (!arg || (arg->argc != ARRAYSIZE(args)) || !arg->argv)
+		goto fail;
+
+	/* Check invalid parameters */
+	ret = freerdp_addin_replace_argument_value(NULL, "bar", "foo", newarg1);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_replace_argument_value(arg, NULL, "foo", newarg1);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_replace_argument_value(arg, "foo", NULL, newarg1);
+	if (ret >= 0)
+		goto fail;
+	ret = freerdp_addin_replace_argument_value(arg, "bar", "foo", NULL);
+	if (ret >= 0)
+		goto fail;
+
+	/* Try existing parameter */
+	ret = freerdp_addin_replace_argument_value(arg, "bla", "foo", newarg1);
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)) || (strcmp(arg->argv[3], fullnewarg1) != 0))
+		goto fail;
+	ret = freerdp_addin_replace_argument_value(arg, "foo", "foo", newarg2);
+	if ((ret != 1) || (arg->argc != ARRAYSIZE(args)) || (strcmp(arg->argv[0], fullnewarg2) != 0))
+		goto fail;
+
+	/* Try new parameter */
+	ret = freerdp_addin_replace_argument_value(arg, "hahaha", newarg2, newarg1);
+	if ((ret != 0) || (arg->argc != ARRAYSIZE(args) + 1) ||
+	    (strcmp(fullnewvalue, arg->argv[ARRAYSIZE(args)]) != 0))
+		goto fail;
+
+	rc = TRUE;
+fail:
+	freerdp_addin_argv_free(arg);
+	printf("%s: %d\n", __func__, rc);
+	return rc;
+}
+
+int TestAddinArgv(int argc, char* argv[])
+{
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	if (!test_alloc())
+		return -1;
+	if (!test_clone())
+		return -1;
+	if (!test_add_remove())
+		return -1;
+	if (!test_set_argument())
+		return -1;
+	if (!test_replace_argument())
+		return -1;
+	if (!test_set_argument_value())
+		return -1;
+	if (!test_replace_argument_value())
+		return -1;
+	return 0;
+}
diff --git a/libfreerdp/common/test/TestCommonAssistance.c b/libfreerdp/common/test/TestCommonAssistance.c
new file mode 100644
index 0000000..35fe863
--- /dev/null
+++ b/libfreerdp/common/test/TestCommonAssistance.c
@@ -0,0 +1,293 @@
+#include <winpr/crt.h>
+#include <winpr/print.h>
+#include <winpr/ssl.h>
+#include <winpr/wlog.h>
+#include <winpr/platform.h>
+
+#include <freerdp/assistance.h>
+
+static const char TEST_MSRC_INCIDENT_PASSWORD_TYPE1[] = "Password1";
+
+static const char TEST_MSRC_INCIDENT_FILE_TYPE1[] =
+    "<?xml version=\"1.0\" encoding=\"Unicode\" ?>"
+    "<UPLOADINFO TYPE=\"Escalated\">"
+    "<UPLOADDATA "
+    "USERNAME=\"Administrator\" "
+    "RCTICKET=\"65538,1,10.0.3.105:3389;winxpsp3.contoso3.com:3389,*,"
+    "rb+v0oPmEISmi8N2zK/vuhgul/ABqlDt6wW0VxMyxK8=,*,*,IuaRySSbPDNna4+2mKcsKxsbJFI=\""
+    "RCTICKETENCRYPTED=\"1\" "
+    "DtStart=\"1314905741\" "
+    "DtLength=\"180\" "
+    "PassStub=\"RT=0PvIndan52*\" "
+    "L=\"0\" />"
+    "</UPLOADINFO>";
+
+WINPR_PRAGMA_DIAG_PUSH
+WINPR_PRAGMA_DIAG_IGNORED_UNUSED_CONST_VAR
+static const BYTE TEST_MSRC_INCIDENT_EXPERT_BLOB_TYPE1[32] =
+    "\x3C\x9C\xAE\x0B\xCE\x7A\xB1\x5C\x8A\xAC\x01\xD6\x76\x04\x5E\xDF"
+    "\x3F\xFA\xF0\x92\xE2\xDE\x36\x8A\x20\x17\xE6\x8A\x0D\xED\x7C\x90";
+WINPR_PRAGMA_DIAG_POP
+
+static const char TEST_MSRC_INCIDENT_PASSWORD_TYPE2[] = "48BJQ853X3B4";
+
+static const char TEST_MSRC_INCIDENT_FILE_TYPE2[] =
+    "<?xml version=\"1.0\"?>"
+    "<UPLOADINFO TYPE=\"Escalated\">"
+    "<UPLOADDATA USERNAME=\"awake\" "
+    "LHTICKET=\""
+    "20FCC407AA53E95F8505AB56D485D26835064B03AF86CDA326248FD304626AD4"
+    "DBDBDFFE0C473228EFFF7A1E6CEB445BBEC429294BB6616BBB600854438DDFB5"
+    "82FC377CF65A2060EB3221647643C9B29BF5EC320856180B34D1BE9827A528C7"
+    "E8F0DCD53C8D38F974160FEE317458FAC9DBDBA7B972D21DF3BC5B1AF0E01878"
+    "65F07A3B915618C03E6EAF843FC1185770A1208C29C836DBCA5A040CB276D3C4"
+    "1DDE2FA8CA9627E5E74FA750A92C0E01AD6C3D1000A5B1479DEB899BF5BCD402"
+    "CE3BB3BF104CE0286C3F985AA711943C88C5EEEEE86F35B63F68883A90ADBCFD"
+    "CBBAE3EAB993EFD9148E1A21D092CE9498695943946236D65D20B4A38D724C61"
+    "72319E38E19C04E98EBC03F56A4A190E971F8EAEBFE6B415A3A2D8F35F7BF785"
+    "26B9BFAAB48D11BDD6C905EFE503D2265678E1EAD2F2F124E570667F04103180"
+    "2F63587276C14E6A5AB436CE234F722CE7C9B5D244508F14C012E84A49FE6992"
+    "3F30320ABB3641F1EFA66205F3EA709E7E1C3E6874BB9642486FB96D2730CDF4"
+    "514AA738167F00FC13B2978AED1D6678413FDF62008B03DD729E36173BE02742"
+    "B69CAD44938512D0F56335394759338AF6ADBCF39CE829116D97435085D05BB5"
+    "9320A134698050DCDBE01305A6B4712FD6BD48958BD2DC497498FF35CAECC9A8"
+    "2C97FD1A5B5EC4BAF5FFB75A1471B765C465B35A7C950019066BB219B391C6E9"
+    "8AE8FD2038E774F36F226D9FB9A38BCC313785612165D1EF69D19E2B9CF6E0F7"
+    "FE1ECCF00AB81F9E8B626363CA82FAC719A3B7D243325C9D6042B2488EC95B80"
+    "A31273FF9B72FBBB86F946E6D3DF8816BE4533F0B547C8BC028309EA9784C1E6\" "
+    "RCTICKET=\"65538,1,192.168.1.200:49230;169.254.6.170:49231,*,"
+    "+ULZ6ifjoCa6cGPMLQiGHRPwkg6VyJqGwxMnO6GcelwUh9a6/FBq3It5ADSndmLL,"
+    "*,*,BNRjdu97DyczQSRuMRrDWoue+HA=\" "
+    "PassStub=\"WB^6HsrIaFmEpi\" "
+    "RCTICKETENCRYPTED=\"1\" "
+    "DtStart=\"1403972263\" "
+    "DtLength=\"14400\" "
+    "L=\"0\"/>"
+    "</UPLOADINFO>";
+
+/**
+ * Decrypted Connection String 2:
+ *
+ * <E>
+ * <A KH="BNRjdu97DyczQSRuMRrDWoue+HA="
+ * ID="+ULZ6ifjoCa6cGPMLQiGHRPwkg6VyJqGwxMnO6GcelwUh9a6/FBq3It5ADSndmLL"/> <C> <T ID="1" SID="0"> <L
+ * P="49228" N="fe80::1032:53d9:5a01:909b%3"/> <L P="49229" N="fe80::3d8f:9b2d:6b4e:6aa%6"/> <L
+ * P="49230" N="192.168.1.200"/> <L P="49231" N="169.254.6.170"/>
+ * </T>
+ * </C>
+ * </E>
+ */
+static const char connectionstr2[] =
+    "<E>\n"
+    "<A KH=\"YiKwWUY8Ioq5NB3wAQHSbs5kwrM=\"\n"
+    "KH2=\"sha256:wKSAkAV3sBfa9WpuRFJcP9q1twJc6wOBuoJ9tsyXwpk=\"\n"
+    "ID=\"8rYm30RBW8/4dAWoUsWbFCF5jno/7jr5tNpHQc2goLbw4uuBBJvLsU02YYLlBMg5\"/>\n"
+    "<C>\n"
+    "<T ID=\"1\" SID=\"1440550163\">\n"
+    "<L P=\"49749\" N=\"2001:4898:1a:5:79e2:3356:9b22:3470\"/>\n"
+    "<L P=\"49751\" N=\"172.31.250.64\"/>\n"
+    "</T>\n"
+    "</C>\n"
+    "</E>";
+
+static const char* fail_tests[] = {
+	"<UPLOADINFOTYPE=\"Escalated\"><UPLOADDATARCTICKET=\"65538,1, ,*,,*,*,\"/></UPLOADINFO>",
+	"<UPLOADINFO>(E><UPLOADDATA  "
+	"FOTYPE=\"Escalated\"æÁATAPassStub=\"␕:&A&amp;␅RCTICKET=\"65538,1,ü,*,n,*,*,\"am␡/>␂</"
+	"UPLOADINFO>"
+};
+
+static const char connectionstr3[] =
+    "<?xml version=\"1.0\"?>\n"
+    "<UPLOADINFO TYPE=\"Escalated\"><UPLOADDATA USERNAME=\"fx\" "
+    "LHTICKET="
+    "\"F9BBA098D84E1B20E37CD0983D9336B1FF4929925FCE5F3A1A9B9A596A524F2E169AD26D84255C7E8C0B88304A4C"
+    "40E0544624AD346A6828D6F2091C36C1315BD11255FE631F3A457F862FFD9948C496BC4B705B0AD2F26D0CDF7128E4"
+    "8625C8C501326B33888D42C591434F7ED4BBA0CEE02C8554921E49BCF130E1961F38FD0F0B7333001E639F89471940"
+    "93136CA5030EC4A92D05341488B79C40E11B28E1753F38682816EDF756CF5204943FD3F60DDD16416D220CA162B6FB"
+    "D43CC00C4F9D3F9FCF68ADAF191470B75EA4E8B37D03D2B9D3D844F54597D75FFF0A6216811518A3D06B26CA95F733"
+    "CCE8A46A4B1FF8F514971A1C06A8DC9D1DD0863087707045D3FCB74BB0444AF8B822FD6605DA68D8D628A7D8556212"
+    "D10F5BC4B1B7905E863F51346114FFED6A46D67314F3B933DF17F8A2E5EC6DAD2904349AC710E017652171A98C8621"
+    "4AF3801B1441E641CDA159BE76D8F2415129773283B5A4E0E7483580E6955B54B0E1432129612CFECD6770201F4206"
+    "1732E748B7F8A0C015EA8B36610962AC208C26373A483E830C7E01330492C9CBAB308A5E19272CC06F0F8008068816"
+    "78F8FB32667D876F6060C50D1A1251DDB9B339E2F846F48C0C7751BBDFF2138152B7A048AFECB31F6DE340E81EB8A4"
+    "EC7F8208B81E11E13033659B885686FEDF6881355679DCD96661201E5BC59D6C6EEFA1608B9E73E75F42D51A26E236"
+    "3690714D58A846B48E0AA2C753CA6347BAEA59CDCA5144527F3A69B560980BCC5DB77AC0FD1A68D19F802744D723D8"
+    "6595A48D1F72DAD0E3E61BA4D37E24EAAB9F49F21753CD481D6744036CA49DA0E432B961F48810FE90EB49DB0FB450"
+    "5FB316DCCAAC51E647B333EBA1C219A68F0A08BD65C9E4ED231D40EA15C2CEB80CB161495A0CADECAF2A00B5916AA9"
+    "91B78C7B17F26DA880DE25DFC09D9D823E174A8401CBC846D2A8B29B6B26EE92261C71C37E3C816540F77CB6DE916B"
+    "FCC7ED100949503251687B860E4A5F5B51CDADD11FF5CA408FA38E4A2AD6FA09D10E9B85523236D55132CD42936150"
+    "51913820DAE06877AC2954651049A157730A1AB67BD9A258CCB3A71909A8686F6F742FBC55312B041342C5475F808A"
+    "B04B629B99A1C69200740CDA5FE1602518B3117FB9835060BEF22EBAF20676662C9E0C3ED39C01E2F9A0822A2ADA07"
+    "D4718A93516AA04E4527C699A00FA8AFCAC7337F8D42949B3CB9F35A19BF5AC9BBF412C9E4AE82C593897BFF81240C"
+    "002486DF0F14845BB12A15966E95A9B6090C6512AF8B717F720F0CE452AA602106B65B98374CBCF9F6B5300FB077E5"
+    "554B489F6913E3857E352C94929A69C86EB13A67B872BB69980B9B3A1E05D6B9483C26A0D6D83CCD4C1AB6C21BA625"
+    "A5232C25BC1B7EB8B954B52D91B1BDF4277B2DCE039F4DBE2F18AE22533C2B877AB27B157ACE5DF21BC83E72104A31"
+    "C253704FDB2536308280D7172313F5D19D088E4C7F4F79C4786D6C65DEAB7FC16DE107AF8C61626502FA940497987F"
+    "60759878E40EDFAC98DED90BEA26E3020AA36A7307F2C9A9D5B19FAA34DF3633F643425F16A3615C996691EC705617"
+    "97CEB08463CBD0150F6B4C01BF1337E3B8B5E5355F62AD1AF949FCB3671327EA5AABC90081117E6CE11C6C42CF6E0E"
+    "DCB4C63EA9433D89F1030F65EDC82D45289C6367BF1E004D338CED13B7643C8708C42FF3671377A79DBFE3E4A39E19"
+    "F4759B84AA9CB03D64C2DBF5D2908DE64F5534AC07C11723F3A7602E307625F86B410BC7B54D85145B9F362E181860"
+    "AEF3574682CE4F3C57742870ED0B228CAC0E9183BD07BFF0435989263CA7EBF21B8CF25DBC2C7915FEB1000848A52F"
+    "94E7B34A416A826BFB1792E64F1CEA7FA3222131C53FA6DE38A786C99C355FE9C9D55B91D11B19087F1574CFF28C4D"
+    "AA9DE974A0939F0C13E9C408167ABAB90BD6BB25FA37B1588AAA3687AC86818543FEFD6E46D821D7F68BE1B0793585"
+    "4E7A81F6C9A0965159DAFF7B0E79C89A18DA3C52D6259EA711ED6B85CCC207AA35F62CB5D48299DAD003004702716E"
+    "65A96390033F8006FC7E7B1A09B9D1C6C17EC20811DE09EC19EB36844E45FCA18CF657A81E5922AB1B805721A5457E"
+    "01EB86334877FEDA378EDE6190491015158194ED1DEE3A99770DB8B9A87BC9FAE29A0AC17C4963DF07109B05AABA73"
+    "1A6AACDB8A02795CBDA935D51D0A7ABB35D8D1B6E598751E45BD507EC2778E285BEBAB2B50462FED1975B5A87F9751"
+    "25A6F272560E756CC941CF6D22FE72F7563CB2687E56F2FA2FC07FE01F3C8E6FCF7D4ECD60C1A53B98CA57AFB5BA18"
+    "97D4F530FCDEBDEB015D9CB1DE0BED20B7C3221283E292C252C742C23401B2E5A85EBD63E6916C3051FEAA1DC57975"
+    "410487AD7EE6CA0A346FE44F901E8BA81A7B398E94707E094081AE6391696EC42DD3F4B9189AB2A5311811481A48FB"
+    "0FAEFC1E9858547D15AA2F6FF01191F8EEC3564C59172605DA16C94F466156BE7A3E98E8C53BE50B671DEC5A3BD8A9"
+    "8C2A1B3FF47D27007AB17A4A1E155E094E3EA30FF531FBF6320F23BA57B3CAF8C470E176C93FACEE829C58B2399975"
+    "EBC4688B2F55132D102E83E45976C6607A57B90F43A33BCB68C03671E632B0E7C17B18406161AB46A8A0992DA7046A"
+    "08135E04142B68312BE3D0F7F5BBAE914E8DC5AAD04D992DA18FAB5B01EA34A0E27B253E92BEFE607578B1C79D4DAC"
+    "07DA6F92986F12AE036C227E4495662C46762E66EA3EC71C5C04BADD9DEDCAD725C16710825394179CFD17EDE482BA"
+    "11C421D0B4C806A2ED963831FAB4DE14FEAA904A3C5173AB9B86FCFF81E0F60DB45182A2471BC16DA992553EAE99DD"
+    "716E85DB11AC0F32BC960D6E8F6BE2250D59EDCAA69C19AF04E21362331225F94BD600EE76E1719417480AB6DC62DF"
+    "958DCCE951EBC64B4600DF3A826B9E702C536C0DF9E2952EDA7FAE6076C6F25CF41C0F7751768EC3C3293D727F8541"
+    "E997DA23E2D952D782B0472B3BFBC638CBDFDA43F367E3F6A7AAC9C8B07D51459432AEBB11564A669BF2EC1658B361"
+    "BE29B47F905352D13705E1E7F06B68A5F247B9FFA3B917CC54F7367386502A42F32CEE474F5E4D35CB5A44C3BA2192"
+    "A3F61DC334CE6D91E36D1C891E65A30C1E2B8F66A01B5DA8DDFB5CD051D61BD39B2E0516C6715F9AA7FE262BBD9BA4"
+    "CE8B785B42CA9582AD5EE24F8C11D2DA0DC6383506DE46C5187C03A930E5E507812A505884121C8A93C2569B269AE7"
+    "A26FDCF0BF7FA996250FFF790C3E97565B27C8DECFE5A15E2ED1A853FBF5D12207B8D3564CDD99549E508E92CB53DB"
+    "F6356F6EBF03E6A6672BFDE285A3DF84105F7C7E39577838C06B50D2ABB4F1C0377D45BE016ED022804F6BD9151BCD"
+    "883CE5FE8358798EE4EA3C24C67815D535CBCFA36094D7418EC104F90609C7AC008D07FDF89A6B3A0B5EC505E17DEC"
+    "57DA6256F4B2CC7DFF4E643FE89E4934440E2A360F035FA9C91F0F657A88AC9E7210A9ABAAAEA26D6B717EEAF231FB"
+    "79A0838B4BB85C11C9675F2BC746230F79A88137F911809C472750A5F6BB9415298C638FC3E24FA1763ACB513A4200"
+    "CB0BF550BC7DE0D2DC5D45AF18FF6073D96D2E4368A637B78257D087C9A471CC88E3368E810BFC29002D86C898F75D"
+    "3F6AE13648841038FDD1D3E8C4D2D5A4E1044614CAF544758A68F4947E3A3E736255CF01FE7A40A6FF136E7458F13D"
+    "759086A544FA14B47155511F784A2144E2B139EC5B5F3B0CAB52E511AAF84E00ABB4115644D42B0A7F91DA53F5C54D"
+    "744C583F5E838D402512A9644772E256CACCAA90ED300AE1616FDAA8309E5FB3FD92EB09F32216446CA2E737E8C136"
+    "C3E773FB986060A78D87CDF7CD92B187188CA7293998F0BC33C13A2FD8C7B0A76C2DAA662F0A71965E25930294D351"
+    "947DDE4800A237871F6BBFA77B7440339BFAE36035A84DA6AD87AA57FD52F7CDA342EB3D7B3E46F64592DFF327194C"
+    "D80C83272B5159BD97A9254089C90E1AFC7C30265BA814ED485550E4E4157FEDB14D9FB6D05AEE5983C81E799DF134"
+    "00766571BDBC8AC719AA2228C9DD592C102DE18A3F1C4B3501C6B29424B83B71D1740B1775967CFC984BC2D22C15\""
+    " PassStub=\"e4=3CiFuM6h2qH\" RCTICKETENCRYPTED=\"1\" DtStart=\"1704288424\" DtLength=\"360\" "
+    "L=\"0\"/>"
+    "</UPLOADINFO>";
+static const char connectionpwd3[] = "4X638PTVZTKZ";
+
+static BOOL run_test_parse(wLog* log, const char* input, size_t len, const char* password,
+                           BOOL expect)
+{
+	rdpAssistanceFile* file = freerdp_assistance_file_new();
+	if (!file)
+		return FALSE;
+
+	const int status = freerdp_assistance_parse_file_buffer(file, input, len, password);
+	const BOOL success = status >= 0;
+
+	freerdp_assistance_print_file(file, log, WLOG_INFO);
+	freerdp_assistance_file_free(file);
+	return success == expect;
+}
+
+static BOOL test_file_to_settings(wLog* log, rdpAssistanceFile* file)
+{
+	rdpSettings* settings = freerdp_settings_new(0);
+	if (!settings)
+		return FALSE;
+	const BOOL rc = freerdp_assistance_populate_settings_from_assistance_file(file, settings);
+	freerdp_settings_free(settings);
+	return rc;
+}
+
+static BOOL test_file_from_buffer(wLog* log, const char* data, size_t size, const char* pwd)
+{
+	BOOL rc = FALSE;
+	int status = 0;
+	char* pass = NULL;
+	char* expertBlob = NULL;
+	const char* EncryptedPassStub = NULL;
+	size_t EncryptedPassStubLength = 0;
+	rdpAssistanceFile* file = freerdp_assistance_file_new();
+
+	if (!file)
+		return FALSE;
+
+	status = freerdp_assistance_parse_file_buffer(file, data, size, pwd);
+	WLog_Print(log, WLOG_INFO, "freerdp_assistance_parse_file_buffer: %d", status);
+
+	if (status < 0)
+		goto fail;
+
+	freerdp_assistance_print_file(file, WLog_Get("foo"), WLOG_INFO);
+
+	if (!freerdp_assistance_get_encrypted_pass_stub(file, &EncryptedPassStub,
+	                                                &EncryptedPassStubLength))
+		goto fail;
+
+	if (EncryptedPassStubLength > 0)
+	{
+		pass = freerdp_assistance_bin_to_hex_string(EncryptedPassStub, EncryptedPassStubLength);
+
+		if (!pass)
+			goto fail;
+
+		WLog_Print(log, WLOG_INFO, "freerdp_assistance_decrypt: %d %s [%" PRIdz "]", status, pass,
+		           EncryptedPassStubLength);
+		expertBlob = freerdp_assistance_construct_expert_blob("Edgar Olougouna", pass);
+
+		WLog_Print(log, WLOG_INFO, "expertBlob='%s'", expertBlob);
+	}
+	rc = test_file_to_settings(log, file);
+fail:
+	freerdp_assistance_file_free(file);
+	free(pass);
+	free(expertBlob);
+	return rc;
+}
+
+static BOOL test_msrsc_incident_file_type1(wLog* log)
+{
+	return test_file_from_buffer(log, TEST_MSRC_INCIDENT_FILE_TYPE1,
+	                             sizeof(TEST_MSRC_INCIDENT_FILE_TYPE1),
+	                             TEST_MSRC_INCIDENT_PASSWORD_TYPE1);
+}
+
+static BOOL test_msrsc_incident_file_type2(wLog* log)
+{
+	if (!test_file_from_buffer(log, connectionstr2, sizeof(connectionstr2),
+	                           TEST_MSRC_INCIDENT_PASSWORD_TYPE2))
+		return FALSE;
+	if (!test_file_from_buffer(log, connectionstr3, sizeof(connectionstr3), connectionpwd3))
+		return FALSE;
+	if (!test_file_from_buffer(log, TEST_MSRC_INCIDENT_FILE_TYPE2,
+	                           sizeof(TEST_MSRC_INCIDENT_FILE_TYPE2),
+	                           TEST_MSRC_INCIDENT_PASSWORD_TYPE2))
+		return FALSE;
+	return TRUE;
+}
+
+int TestCommonAssistance(int argc, char* argv[])
+{
+	wLog* log = NULL;
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+	log = WLog_Get(__func__);
+	winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
+
+	for (size_t x = 0; x < ARRAYSIZE(fail_tests); x++)
+	{
+		const char* test = fail_tests[x];
+		const size_t len = strlen(test);
+
+		if (!run_test_parse(log, test, len + 1, NULL, FALSE))
+			return -1;
+	}
+
+	if (!test_msrsc_incident_file_type1(log))
+	{
+		WLog_Print(log, WLOG_ERROR, "test_msrsc_incident_file_type1 failed");
+		return -1;
+	}
+
+	if (!test_msrsc_incident_file_type2(log))
+	{
+		WLog_Print(log, WLOG_ERROR, "test_msrsc_incident_file_type2 failed");
+		return -1;
+	}
+
+	return 0;
+}
diff --git a/libfreerdp/common/test/TestFuzzCommonAssistanceBinToHexString.c b/libfreerdp/common/test/TestFuzzCommonAssistanceBinToHexString.c
new file mode 100644
index 0000000..6b23c78
--- /dev/null
+++ b/libfreerdp/common/test/TestFuzzCommonAssistanceBinToHexString.c
@@ -0,0 +1,8 @@
+#include <freerdp/assistance.h>
+
+int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
+{
+	char* pass = freerdp_assistance_bin_to_hex_string((void*)Data, Size);
+	free(pass);
+	return 0;
+}
diff --git a/libfreerdp/common/test/TestFuzzCommonAssistanceHexStringToBin.c b/libfreerdp/common/test/TestFuzzCommonAssistanceHexStringToBin.c
new file mode 100644
index 0000000..b0847d8
--- /dev/null
+++ b/libfreerdp/common/test/TestFuzzCommonAssistanceHexStringToBin.c
@@ -0,0 +1,16 @@
+#include <freerdp/assistance.h>
+
+int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
+{
+	char* buf = calloc(Size + 1, sizeof(char));
+	if (buf == NULL)
+		return 0;
+	memcpy(buf, Data, Size);
+	buf[Size] = '\0';
+
+	BYTE* pass = freerdp_assistance_hex_string_to_bin((void*)buf, &Size);
+	free(pass);
+	free(buf);
+
+	return 0;
+}
diff --git a/libfreerdp/common/test/TestFuzzCommonAssistanceParseFileBuffer.c b/libfreerdp/common/test/TestFuzzCommonAssistanceParseFileBuffer.c
new file mode 100644
index 0000000..1900977
--- /dev/null
+++ b/libfreerdp/common/test/TestFuzzCommonAssistanceParseFileBuffer.c
@@ -0,0 +1,31 @@
+#include <freerdp/assistance.h>
+
+static int parse_file_buffer(const uint8_t* Data, size_t Size)
+{
+	static const char TEST_MSRC_INCIDENT_PASSWORD_TYPE2[] = "48BJQ853X3B4";
+	int status = -1;
+	rdpAssistanceFile* file = freerdp_assistance_file_new();
+	if (!file)
+		return -1;
+
+	char* buf = calloc(Size + 1, sizeof(char));
+	if (buf == NULL)
+		goto err;
+	memcpy(buf, Data, Size);
+	buf[Size] = '\0';
+
+	status = freerdp_assistance_parse_file_buffer(file, (char*)buf, Size + 1,
+	                                              TEST_MSRC_INCIDENT_PASSWORD_TYPE2);
+
+err:
+	freerdp_assistance_file_free(file);
+	free(buf);
+
+	return status >= 0 ? TRUE : FALSE;
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
+{
+	parse_file_buffer(Data, Size);
+	return 0;
+}