Added expert settings /tune and /tune-list

diff --git a/client/common/cmdline.c b/client/common/cmdline.c
index e57a2cd..cdea23d 100644 (file)
--- a/client/common/cmdline.c
+++ b/client/common/cmdline.c
@@ -3186,6 +3186,89 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
                        if (!settings->SmartcardLogon)
                                activate_smartcard_logon_rdp(settings);
                }
+
+               CommandLineSwitchCase(arg, "tune")
+               {
+                       size_t x, count;
+                       char** p = CommandLineParseCommaSeparatedValuesEx("tune", arg->Value, &count);
+                       if (!p)
+                               return COMMAND_LINE_ERROR;
+                       for (x = 1; x < count; x++)
+                       {
+                               char* cur = p[x];
+                               char* sep = strchr(cur, ':');
+                               if (!sep)
+                               {
+                                       free(p);
+                                       return COMMAND_LINE_ERROR;
+                               }
+                               *sep++ = '\0';
+                               if (!freerdp_settings_set_value_for_name(settings, cur, sep))
+                               {
+                                       free(p);
+                                       return COMMAND_LINE_ERROR;
+                               }
+                       }
+
+                       free(p);
+               }
+               CommandLineSwitchCase(arg, "tune-list")
+               {
+                       size_t x;
+                       SSIZE_T type = 0;
+
+                       printf("%s\t%50s\t%s\t%s", "<index>", "<key>", "<type>", "<default value>\n");
+                       for (x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
+                       {
+                               const char* name = freerdp_settings_get_name_for_key(x);
+                               type = freerdp_settings_get_type_for_key(x);
+
+                               switch (type)
+                               {
+                                       case RDP_SETTINGS_TYPE_BOOL:
+                                               printf("%" PRIuz "\t%50s\tBOOL\t%s\n", x, name,
+                                                      freerdp_settings_get_bool(settings, x) ? "TRUE" : "FALSE");
+                                               break;
+                                       case RDP_SETTINGS_TYPE_UINT16:
+                                               printf("%" PRIuz "\t%50s\tUINT16\t%" PRIu16 "\n", x, name,
+                                                      freerdp_settings_get_uint16(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_INT16:
+                                               printf("%" PRIuz "\t%50s\tINT16\t%" PRId16 "\n", x, name,
+                                                      freerdp_settings_get_int16(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_UINT32:
+                                               printf("%" PRIuz "\t%50s\tUINT32\t%" PRIu32 "\n", x, name,
+                                                      freerdp_settings_get_uint32(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_INT32:
+                                               printf("%" PRIuz "\t%50s\tINT32\t%" PRId32 "\n", x, name,
+                                                      freerdp_settings_get_int32(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_UINT64:
+                                               printf("%" PRIuz "\t%50s\tUINT64\t%" PRIu64 "\n", x, name,
+                                                      freerdp_settings_get_uint64(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_INT64:
+                                               printf("%" PRIuz "\t%50s\tINT64\t%" PRId64 "\n", x, name,
+                                                      freerdp_settings_get_int64(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_STRING:
+                                               printf("%" PRIuz "\t%50s\tSTRING\t%s"
+                                                      "\n",
+                                                      x, name, freerdp_settings_get_string(settings, x));
+                                               break;
+                                       case RDP_SETTINGS_TYPE_POINTER:
+                                               printf("%" PRIuz "\t%50s\tPOINTER\t%p"
+                                                      "\n",
+                                                      x, name, freerdp_settings_get_pointer(settings, x));
+                                               break;
+                                       default:
+                                               break;
+                               }
+                       }
+                       return COMMAND_LINE_STATUS_PRINT;
+               }
                CommandLineSwitchDefault(arg)
                {
                }

diff --git a/client/common/cmdline.h b/client/common/cmdline.h
index 6035059..3ae8af1 100644 (file)
--- a/client/common/cmdline.h
+++ b/client/common/cmdline.h
@@ -344,6 +344,10 @@ static const COMMAND_LINE_ARGUMENT_A args[] = {
          "TLS security level - defaults to 1" },
        { "toggle-fullscreen", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueTrue, NULL, -1, NULL,
          "Alt+Ctrl+Enter to toggle fullscreen" },
+       { "tune", COMMAND_LINE_VALUE_REQUIRED, "<setting:value>,<setting:value>", "", NULL, -1, NULL,
+         "[experimental] directly manipulate freerdp settings, use with extreme caution!" },
+       { "tune-list", COMMAND_LINE_VALUE_FLAG, NULL, NULL, NULL, -1, NULL,
+         "Print options allowed for /tune" },
        { "u", COMMAND_LINE_VALUE_REQUIRED, "[[<domain>\\]<user>|<user>[@<domain>]]", NULL, NULL, -1,
          NULL, "Username" },
        { "unmap-buttons", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueFalse, NULL, -1, NULL,

diff --git a/include/freerdp/settings.h b/include/freerdp/settings.h
index b913f7b..99bc0d2 100644 (file)
--- a/include/freerdp/settings.h
+++ b/include/freerdp/settings.h
@@ -894,6 +894,7 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL;
  * FreeRDP Settings Data Structure
  */
 
+#define FreeRDP_Settings_StableAPI_MAX 5312
 struct rdp_settings
 {
        /**
@@ -1561,6 +1562,19 @@ struct rdp_settings
 };
 typedef struct rdp_settings rdpSettings;
 
+enum rdp_settings_type
+{
+       RDP_SETTINGS_TYPE_BOOL,
+       RDP_SETTINGS_TYPE_UINT16,
+       RDP_SETTINGS_TYPE_INT16,
+       RDP_SETTINGS_TYPE_UINT32,
+       RDP_SETTINGS_TYPE_INT32,
+       RDP_SETTINGS_TYPE_UINT64,
+       RDP_SETTINGS_TYPE_INT64,
+       RDP_SETTINGS_TYPE_STRING,
+       RDP_SETTINGS_TYPE_POINTER
+};
+
 #ifdef __cplusplus
 extern "C"
 {
@@ -1670,6 +1684,14 @@ extern "C"
 
        FREERDP_API const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id);
 
+       FREERDP_API BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name,
+                                                            const char* value);
+
+       FREERDP_API SSIZE_T freerdp_settings_get_key_for_name(const char* value);
+       FREERDP_API SSIZE_T freerdp_settings_get_type_for_name(const char* value);
+       FREERDP_API SSIZE_T freerdp_settings_get_type_for_key(size_t key);
+       FREERDP_API const char* freerdp_settings_get_name_for_key(size_t key);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/libfreerdp/common/CMakeLists.txt b/libfreerdp/common/CMakeLists.txt
index fa8b817..c0274bf 100644 (file)
--- a/libfreerdp/common/CMakeLists.txt
+++ b/libfreerdp/common/CMakeLists.txt
@@ -22,6 +22,7 @@ set(${MODULE_PREFIX}_SRCS
        addin.c
        settings.c
        settings_getters.c
+       settings_str.c
        assistance.c)
 
 freerdp_module_add(${${MODULE_PREFIX}_SRCS})

diff --git a/libfreerdp/common/settings.c b/libfreerdp/common/settings.c
index 6ca65f2..b639778 100644 (file)
--- a/libfreerdp/common/settings.c
+++ b/libfreerdp/common/settings.c
@@ -25,6 +25,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 
 #include <winpr/crt.h>
 
@@ -804,3 +805,123 @@ int freerdp_set_param_string(rdpSettings* settings, int id, const char* param)
 {
        return freerdp_settings_set_string(settings, (size_t)id, param) ? 0 : -1;
 }
+
+static BOOL value_to_uint(const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
+{
+       unsigned long long rc;
+
+       if (!value || !result)
+               return FALSE;
+
+       errno = 0;
+       rc = _strtoui64(value, NULL, 0);
+
+       if (errno != 0)
+               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)
+{
+       long long rc;
+
+       if (!value || !result)
+               return FALSE;
+
+       errno = 0;
+       rc = _strtoi64(value, NULL, 0);
+
+       if (errno != 0)
+               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;
+       LONGLONG ival;
+       SSIZE_T index, type;
+       if (!settings || !name)
+               return FALSE;
+
+       index = freerdp_settings_get_key_for_name(name);
+       if (index < 0)
+       {
+               WLog_ERR(TAG, "Invalid settings key [%s]", name);
+               return FALSE;
+       }
+
+       type = freerdp_settings_get_type_for_key((size_t)index);
+       switch (type)
+       {
+
+               case RDP_SETTINGS_TYPE_BOOL:
+               {
+                       BOOL val = _strnicmp(value, "TRUE", 5) == 0;
+                       if (!val && _strnicmp(value, "FALSE", 5) != 0)
+                               return parsing_fail(name, "BOOL", value);
+                       return freerdp_settings_set_bool(settings, 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, 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, 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, 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, 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, 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, index, ival))
+                               return parsing_fail(name, "INT64", value);
+                       return TRUE;
+
+               case RDP_SETTINGS_TYPE_STRING:
+                       return freerdp_settings_set_string(settings, index, value);
+               case RDP_SETTINGS_TYPE_POINTER:
+                       return parsing_fail(name, "POINTER", value);
+               default:
+                       return FALSE;
+       }
+       return FALSE;
+}

diff --git a/libfreerdp/common/settings_getters.c b/libfreerdp/common/settings_getters.c
index 2938ef1..9ea6507 100644 (file)
--- a/libfreerdp/common/settings_getters.c
+++ b/libfreerdp/common/settings_getters.c
@@ -12,128 +12,98 @@ BOOL freerdp_settings_get_bool(const rdpSettings* settings, size_t id)
 
        switch (id)
        {
-               case FreeRDP_ServerMode:
-                       return settings->ServerMode;
-
-               case FreeRDP_WaitForOutputBufferFlush:
-                       return settings->WaitForOutputBufferFlush;
-
-               case FreeRDP_NetworkAutoDetect:
-                       return settings->NetworkAutoDetect;
-
-               case FreeRDP_SupportAsymetricKeys:
-                       return settings->SupportAsymetricKeys;
-
-               case FreeRDP_SupportErrorInfoPdu:
-                       return settings->SupportErrorInfoPdu;
+               case FreeRDP_AllowCacheWaitingList:
+                       return settings->AllowCacheWaitingList;
 
-               case FreeRDP_SupportStatusInfoPdu:
-                       return settings->SupportStatusInfoPdu;
+               case FreeRDP_AllowDesktopComposition:
+                       return settings->AllowDesktopComposition;
 
-               case FreeRDP_SupportMonitorLayoutPdu:
-                       return settings->SupportMonitorLayoutPdu;
+               case FreeRDP_AllowFontSmoothing:
+                       return settings->AllowFontSmoothing;
 
-               case FreeRDP_SupportGraphicsPipeline:
-                       return settings->SupportGraphicsPipeline;
+               case FreeRDP_AllowUnanouncedOrdersFromServer:
+                       return settings->AllowUnanouncedOrdersFromServer;
 
-               case FreeRDP_SupportDynamicTimeZone:
-                       return settings->SupportDynamicTimeZone;
+               case FreeRDP_AltSecFrameMarkerSupport:
+                       return settings->AltSecFrameMarkerSupport;
 
-               case FreeRDP_SupportHeartbeatPdu:
-                       return settings->SupportHeartbeatPdu;
+               case FreeRDP_AsyncChannels:
+                       return settings->AsyncChannels;
 
-               case FreeRDP_UseRdpSecurityLayer:
-                       return settings->UseRdpSecurityLayer;
+               case FreeRDP_AsyncInput:
+                       return settings->AsyncInput;
 
-               case FreeRDP_ConsoleSession:
-                       return settings->ConsoleSession;
+               case FreeRDP_AsyncUpdate:
+                       return settings->AsyncUpdate;
 
-               case FreeRDP_SpanMonitors:
-                       return settings->SpanMonitors;
+               case FreeRDP_AudioCapture:
+                       return settings->AudioCapture;
 
-               case FreeRDP_UseMultimon:
-                       return settings->UseMultimon;
+               case FreeRDP_AudioPlayback:
+                       return settings->AudioPlayback;
 
-               case FreeRDP_ForceMultimon:
-                       return settings->ForceMultimon;
+               case FreeRDP_Authentication:
+                       return settings->Authentication;
 
-               case FreeRDP_ListMonitors:
-                       return settings->ListMonitors;
+               case FreeRDP_AuthenticationOnly:
+                       return settings->AuthenticationOnly;
 
-               case FreeRDP_HasMonitorAttributes:
-                       return settings->HasMonitorAttributes;
+               case FreeRDP_AutoAcceptCertificate:
+                       return settings->AutoAcceptCertificate;
 
-               case FreeRDP_SupportMultitransport:
-                       return settings->SupportMultitransport;
+               case FreeRDP_AutoDenyCertificate:
+                       return settings->AutoDenyCertificate;
 
                case FreeRDP_AutoLogonEnabled:
                        return settings->AutoLogonEnabled;
 
-               case FreeRDP_CompressionEnabled:
-                       return settings->CompressionEnabled;
-
-               case FreeRDP_DisableCtrlAltDel:
-                       return settings->DisableCtrlAltDel;
-
-               case FreeRDP_EnableWindowsKey:
-                       return settings->EnableWindowsKey;
-
-               case FreeRDP_MaximizeShell:
-                       return settings->MaximizeShell;
-
-               case FreeRDP_LogonNotify:
-                       return settings->LogonNotify;
-
-               case FreeRDP_LogonErrors:
-                       return settings->LogonErrors;
-
-               case FreeRDP_MouseAttached:
-                       return settings->MouseAttached;
+               case FreeRDP_AutoReconnectionEnabled:
+                       return settings->AutoReconnectionEnabled;
 
-               case FreeRDP_MouseHasWheel:
-                       return settings->MouseHasWheel;
+               case FreeRDP_BitmapCacheEnabled:
+                       return settings->BitmapCacheEnabled;
 
-               case FreeRDP_RemoteConsoleAudio:
-                       return settings->RemoteConsoleAudio;
+               case FreeRDP_BitmapCachePersistEnabled:
+                       return settings->BitmapCachePersistEnabled;
 
-               case FreeRDP_AudioPlayback:
-                       return settings->AudioPlayback;
+               case FreeRDP_BitmapCacheV3Enabled:
+                       return settings->BitmapCacheV3Enabled;
 
-               case FreeRDP_AudioCapture:
-                       return settings->AudioCapture;
+               case FreeRDP_BitmapCompressionDisabled:
+                       return settings->BitmapCompressionDisabled;
 
-               case FreeRDP_VideoDisable:
-                       return settings->VideoDisable;
+               case FreeRDP_ColorPointerFlag:
+                       return settings->ColorPointerFlag;
 
-               case FreeRDP_PasswordIsSmartcardPin:
-                       return settings->PasswordIsSmartcardPin;
+               case FreeRDP_CompressionEnabled:
+                       return settings->CompressionEnabled;
 
-               case FreeRDP_UsingSavedCredentials:
-                       return settings->UsingSavedCredentials;
+               case FreeRDP_ConsoleSession:
+                       return settings->ConsoleSession;
 
-               case FreeRDP_ForceEncryptedCsPdu:
-                       return settings->ForceEncryptedCsPdu;
+               case FreeRDP_CredentialsFromStdin:
+                       return settings->CredentialsFromStdin;
 
-               case FreeRDP_HiDefRemoteApp:
-                       return settings->HiDefRemoteApp;
+               case FreeRDP_Decorations:
+                       return settings->Decorations;
 
-               case FreeRDP_IPv6Enabled:
-                       return settings->IPv6Enabled;
+               case FreeRDP_DesktopResize:
+                       return settings->DesktopResize;
 
-               case FreeRDP_AutoReconnectionEnabled:
-                       return settings->AutoReconnectionEnabled;
+               case FreeRDP_DeviceRedirection:
+                       return settings->DeviceRedirection;
 
-               case FreeRDP_PrintReconnectCookie:
-                       return settings->PrintReconnectCookie;
+               case FreeRDP_DisableCredentialsDelegation:
+                       return settings->DisableCredentialsDelegation;
 
-               case FreeRDP_DynamicDaylightTimeDisabled:
-                       return settings->DynamicDaylightTimeDisabled;
+               case FreeRDP_DisableCtrlAltDel:
+                       return settings->DisableCtrlAltDel;
 
-               case FreeRDP_AllowFontSmoothing:
-                       return settings->AllowFontSmoothing;
+               case FreeRDP_DisableCursorBlinking:
+                       return settings->DisableCursorBlinking;
 
-               case FreeRDP_DisableWallpaper:
-                       return settings->DisableWallpaper;
+               case FreeRDP_DisableCursorShadow:
+                       return settings->DisableCursorShadow;
 
                case FreeRDP_DisableFullWindowDrag:
                        return settings->DisableFullWindowDrag;
@@ -141,266 +111,272 @@ BOOL freerdp_settings_get_bool(const rdpSettings* settings, size_t id)
                case FreeRDP_DisableMenuAnims:
                        return settings->DisableMenuAnims;
 
+               case FreeRDP_DisableRemoteAppCapsCheck:
+                       return settings->DisableRemoteAppCapsCheck;
+
                case FreeRDP_DisableThemes:
                        return settings->DisableThemes;
 
-               case FreeRDP_DisableCursorShadow:
-                       return settings->DisableCursorShadow;
-
-               case FreeRDP_DisableCursorBlinking:
-                       return settings->DisableCursorBlinking;
-
-               case FreeRDP_AllowDesktopComposition:
-                       return settings->AllowDesktopComposition;
+               case FreeRDP_DisableWallpaper:
+                       return settings->DisableWallpaper;
 
-               case FreeRDP_RemoteAssistanceMode:
-                       return settings->RemoteAssistanceMode;
+               case FreeRDP_DrawAllowColorSubsampling:
+                       return settings->DrawAllowColorSubsampling;
 
-               case FreeRDP_EncomspVirtualChannel:
-                       return settings->EncomspVirtualChannel;
+               case FreeRDP_DrawAllowDynamicColorFidelity:
+                       return settings->DrawAllowDynamicColorFidelity;
 
-               case FreeRDP_RemdeskVirtualChannel:
-                       return settings->RemdeskVirtualChannel;
+               case FreeRDP_DrawAllowSkipAlpha:
+                       return settings->DrawAllowSkipAlpha;
 
-               case FreeRDP_LyncRdpMode:
-                       return settings->LyncRdpMode;
+               case FreeRDP_DrawGdiPlusCacheEnabled:
+                       return settings->DrawGdiPlusCacheEnabled;
 
-               case FreeRDP_RemoteAssistanceRequestControl:
-                       return settings->RemoteAssistanceRequestControl;
+               case FreeRDP_DrawGdiPlusEnabled:
+                       return settings->DrawGdiPlusEnabled;
 
-               case FreeRDP_TlsSecurity:
-                       return settings->TlsSecurity;
+               case FreeRDP_DrawNineGridEnabled:
+                       return settings->DrawNineGridEnabled;
 
-               case FreeRDP_NlaSecurity:
-                       return settings->NlaSecurity;
+               case FreeRDP_DumpRemoteFx:
+                       return settings->DumpRemoteFx;
 
-               case FreeRDP_RdpSecurity:
-                       return settings->RdpSecurity;
+               case FreeRDP_DynamicDaylightTimeDisabled:
+                       return settings->DynamicDaylightTimeDisabled;
 
-               case FreeRDP_ExtSecurity:
-                       return settings->ExtSecurity;
+               case FreeRDP_DynamicResolutionUpdate:
+                       return settings->DynamicResolutionUpdate;
 
-               case FreeRDP_Authentication:
-                       return settings->Authentication;
+               case FreeRDP_EmbeddedWindow:
+                       return settings->EmbeddedWindow;
 
-               case FreeRDP_NegotiateSecurityLayer:
-                       return settings->NegotiateSecurityLayer;
+               case FreeRDP_EnableWindowsKey:
+                       return settings->EnableWindowsKey;
 
-               case FreeRDP_RestrictedAdminModeRequired:
-                       return settings->RestrictedAdminModeRequired;
+               case FreeRDP_EncomspVirtualChannel:
+                       return settings->EncomspVirtualChannel;
 
-               case FreeRDP_DisableCredentialsDelegation:
-                       return settings->DisableCredentialsDelegation;
+               case FreeRDP_ExtSecurity:
+                       return settings->ExtSecurity;
 
-               case FreeRDP_VmConnectMode:
-                       return settings->VmConnectMode;
+               case FreeRDP_ExternalCertificateManagement:
+                       return settings->ExternalCertificateManagement;
 
                case FreeRDP_FIPSMode:
                        return settings->FIPSMode;
 
-               case FreeRDP_MstscCookieMode:
-                       return settings->MstscCookieMode;
-
-               case FreeRDP_SendPreconnectionPdu:
-                       return settings->SendPreconnectionPdu;
-
-               case FreeRDP_SmartcardLogon:
-                       return settings->SmartcardLogon;
-
-               case FreeRDP_PromptForCredentials:
-                       return settings->PromptForCredentials;
-
-               case FreeRDP_IgnoreCertificate:
-                       return settings->IgnoreCertificate;
+               case FreeRDP_FastPathInput:
+                       return settings->FastPathInput;
 
-               case FreeRDP_ExternalCertificateManagement:
-                       return settings->ExternalCertificateManagement;
+               case FreeRDP_FastPathOutput:
+                       return settings->FastPathOutput;
 
-               case FreeRDP_AutoAcceptCertificate:
-                       return settings->AutoAcceptCertificate;
+               case FreeRDP_ForceEncryptedCsPdu:
+                       return settings->ForceEncryptedCsPdu;
 
-               case FreeRDP_AutoDenyCertificate:
-                       return settings->AutoDenyCertificate;
+               case FreeRDP_ForceMultimon:
+                       return settings->ForceMultimon;
 
-               case FreeRDP_Workarea:
-                       return settings->Workarea;
+               case FreeRDP_FrameMarkerCommandEnabled:
+                       return settings->FrameMarkerCommandEnabled;
 
                case FreeRDP_Fullscreen:
                        return settings->Fullscreen;
 
-               case FreeRDP_GrabKeyboard:
-                       return settings->GrabKeyboard;
+               case FreeRDP_GatewayBypassLocal:
+                       return settings->GatewayBypassLocal;
 
-               case FreeRDP_Decorations:
-                       return settings->Decorations;
+               case FreeRDP_GatewayEnabled:
+                       return settings->GatewayEnabled;
 
-               case FreeRDP_MouseMotion:
-                       return settings->MouseMotion;
+               case FreeRDP_GatewayHttpTransport:
+                       return settings->GatewayHttpTransport;
 
-               case FreeRDP_AsyncInput:
-                       return settings->AsyncInput;
+               case FreeRDP_GatewayRpcTransport:
+                       return settings->GatewayRpcTransport;
 
-               case FreeRDP_AsyncUpdate:
-                       return settings->AsyncUpdate;
+               case FreeRDP_GatewayUdpTransport:
+                       return settings->GatewayUdpTransport;
 
-               case FreeRDP_AsyncChannels:
-                       return settings->AsyncChannels;
+               case FreeRDP_GatewayUseSameCredentials:
+                       return settings->GatewayUseSameCredentials;
 
-               case FreeRDP_ToggleFullscreen:
-                       return settings->ToggleFullscreen;
+               case FreeRDP_GfxAVC444:
+                       return settings->GfxAVC444;
 
-               case FreeRDP_EmbeddedWindow:
-                       return settings->EmbeddedWindow;
+               case FreeRDP_GfxAVC444v2:
+                       return settings->GfxAVC444v2;
 
-               case FreeRDP_SmartSizing:
-                       return settings->SmartSizing;
+               case FreeRDP_GfxH264:
+                       return settings->GfxH264;
 
-               case FreeRDP_PercentScreenUseWidth:
-                       return settings->PercentScreenUseWidth;
+               case FreeRDP_GfxProgressive:
+                       return settings->GfxProgressive;
 
-               case FreeRDP_PercentScreenUseHeight:
-                       return settings->PercentScreenUseHeight;
+               case FreeRDP_GfxProgressiveV2:
+                       return settings->GfxProgressiveV2;
 
-               case FreeRDP_DynamicResolutionUpdate:
-                       return settings->DynamicResolutionUpdate;
+               case FreeRDP_GfxSendQoeAck:
+                       return settings->GfxSendQoeAck;
 
-               case FreeRDP_SoftwareGdi:
-                       return settings->SoftwareGdi;
+               case FreeRDP_GfxSmallCache:
+                       return settings->GfxSmallCache;
 
-               case FreeRDP_LocalConnection:
-                       return settings->LocalConnection;
+               case FreeRDP_GfxThinClient:
+                       return settings->GfxThinClient;
 
-               case FreeRDP_AuthenticationOnly:
-                       return settings->AuthenticationOnly;
+               case FreeRDP_GrabKeyboard:
+                       return settings->GrabKeyboard;
 
-               case FreeRDP_CredentialsFromStdin:
-                       return settings->CredentialsFromStdin;
+               case FreeRDP_HasExtendedMouseEvent:
+                       return settings->HasExtendedMouseEvent;
 
-               case FreeRDP_UnmapButtons:
-                       return settings->UnmapButtons;
+               case FreeRDP_HasHorizontalWheel:
+                       return settings->HasHorizontalWheel;
 
-               case FreeRDP_OldLicenseBehaviour:
-                       return settings->OldLicenseBehaviour;
+               case FreeRDP_HasMonitorAttributes:
+                       return settings->HasMonitorAttributes;
 
-               case FreeRDP_DumpRemoteFx:
-                       return settings->DumpRemoteFx;
+               case FreeRDP_HiDefRemoteApp:
+                       return settings->HiDefRemoteApp;
 
-               case FreeRDP_PlayRemoteFx:
-                       return settings->PlayRemoteFx;
+               case FreeRDP_IPv6Enabled:
+                       return settings->IPv6Enabled;
 
-               case FreeRDP_GatewayUseSameCredentials:
-                       return settings->GatewayUseSameCredentials;
+               case FreeRDP_IgnoreCertificate:
+                       return settings->IgnoreCertificate;
 
-               case FreeRDP_GatewayEnabled:
-                       return settings->GatewayEnabled;
+               case FreeRDP_JpegCodec:
+                       return settings->JpegCodec;
 
-               case FreeRDP_GatewayBypassLocal:
-                       return settings->GatewayBypassLocal;
+               case FreeRDP_ListMonitors:
+                       return settings->ListMonitors;
 
-               case FreeRDP_GatewayRpcTransport:
-                       return settings->GatewayRpcTransport;
+               case FreeRDP_LocalConnection:
+                       return settings->LocalConnection;
 
-               case FreeRDP_GatewayHttpTransport:
-                       return settings->GatewayHttpTransport;
+               case FreeRDP_LogonErrors:
+                       return settings->LogonErrors;
 
-               case FreeRDP_GatewayUdpTransport:
-                       return settings->GatewayUdpTransport;
+               case FreeRDP_LogonNotify:
+                       return settings->LogonNotify;
 
-               case FreeRDP_RemoteApplicationMode:
-                       return settings->RemoteApplicationMode;
+               case FreeRDP_LongCredentialsSupported:
+                       return settings->LongCredentialsSupported;
 
-               case FreeRDP_DisableRemoteAppCapsCheck:
-                       return settings->DisableRemoteAppCapsCheck;
+               case FreeRDP_LyncRdpMode:
+                       return settings->LyncRdpMode;
 
-               case FreeRDP_RemoteAppLanguageBarSupported:
-                       return settings->RemoteAppLanguageBarSupported;
+               case FreeRDP_MaximizeShell:
+                       return settings->MaximizeShell;
 
-               case FreeRDP_RefreshRect:
-                       return settings->RefreshRect;
+               case FreeRDP_MouseAttached:
+                       return settings->MouseAttached;
 
-               case FreeRDP_SuppressOutput:
-                       return settings->SuppressOutput;
+               case FreeRDP_MouseHasWheel:
+                       return settings->MouseHasWheel;
 
-               case FreeRDP_FastPathOutput:
-                       return settings->FastPathOutput;
+               case FreeRDP_MouseMotion:
+                       return settings->MouseMotion;
 
-               case FreeRDP_SaltedChecksum:
-                       return settings->SaltedChecksum;
+               case FreeRDP_MstscCookieMode:
+                       return settings->MstscCookieMode;
 
-               case FreeRDP_LongCredentialsSupported:
-                       return settings->LongCredentialsSupported;
+               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_BitmapCompressionDisabled:
-                       return settings->BitmapCompressionDisabled;
+               case FreeRDP_OldLicenseBehaviour:
+                       return settings->OldLicenseBehaviour;
 
-               case FreeRDP_DesktopResize:
-                       return settings->DesktopResize;
+               case FreeRDP_PasswordIsSmartcardPin:
+                       return settings->PasswordIsSmartcardPin;
 
-               case FreeRDP_DrawAllowDynamicColorFidelity:
-                       return settings->DrawAllowDynamicColorFidelity;
+               case FreeRDP_PercentScreenUseHeight:
+                       return settings->PercentScreenUseHeight;
 
-               case FreeRDP_DrawAllowColorSubsampling:
-                       return settings->DrawAllowColorSubsampling;
+               case FreeRDP_PercentScreenUseWidth:
+                       return settings->PercentScreenUseWidth;
 
-               case FreeRDP_DrawAllowSkipAlpha:
-                       return settings->DrawAllowSkipAlpha;
+               case FreeRDP_PlayRemoteFx:
+                       return settings->PlayRemoteFx;
 
-               case FreeRDP_BitmapCacheV3Enabled:
-                       return settings->BitmapCacheV3Enabled;
+               case FreeRDP_PreferIPv6OverIPv4:
+                       return settings->PreferIPv6OverIPv4;
 
-               case FreeRDP_AltSecFrameMarkerSupport:
-                       return settings->AltSecFrameMarkerSupport;
+               case FreeRDP_PrintReconnectCookie:
+                       return settings->PrintReconnectCookie;
 
-               case FreeRDP_AllowUnanouncedOrdersFromServer:
-                       return settings->AllowUnanouncedOrdersFromServer;
+               case FreeRDP_PromptForCredentials:
+                       return settings->PromptForCredentials;
 
-               case FreeRDP_BitmapCacheEnabled:
-                       return settings->BitmapCacheEnabled;
+               case FreeRDP_RdpSecurity:
+                       return settings->RdpSecurity;
 
-               case FreeRDP_AllowCacheWaitingList:
-                       return settings->AllowCacheWaitingList;
+               case FreeRDP_RedirectClipboard:
+                       return settings->RedirectClipboard;
 
-               case FreeRDP_BitmapCachePersistEnabled:
-                       return settings->BitmapCachePersistEnabled;
+               case FreeRDP_RedirectDrives:
+                       return settings->RedirectDrives;
 
-               case FreeRDP_ColorPointerFlag:
-                       return settings->ColorPointerFlag;
+               case FreeRDP_RedirectHomeDrive:
+                       return settings->RedirectHomeDrive;
 
-               case FreeRDP_UnicodeInput:
-                       return settings->UnicodeInput;
+               case FreeRDP_RedirectParallelPorts:
+                       return settings->RedirectParallelPorts;
 
-               case FreeRDP_FastPathInput:
-                       return settings->FastPathInput;
+               case FreeRDP_RedirectPrinters:
+                       return settings->RedirectPrinters;
 
-               case FreeRDP_MultiTouchInput:
-                       return settings->MultiTouchInput;
+               case FreeRDP_RedirectSerialPorts:
+                       return settings->RedirectSerialPorts;
 
-               case FreeRDP_MultiTouchGestures:
-                       return settings->MultiTouchGestures;
+               case FreeRDP_RedirectSmartCards:
+                       return settings->RedirectSmartCards;
 
-               case FreeRDP_HasHorizontalWheel:
-                       return settings->HasHorizontalWheel;
+               case FreeRDP_RefreshRect:
+                       return settings->RefreshRect;
 
-               case FreeRDP_HasExtendedMouseEvent:
-                       return settings->HasExtendedMouseEvent;
+               case FreeRDP_RemdeskVirtualChannel:
+                       return settings->RemdeskVirtualChannel;
 
-               case FreeRDP_SoundBeepsEnabled:
-                       return settings->SoundBeepsEnabled;
+               case FreeRDP_RemoteAppLanguageBarSupported:
+                       return settings->RemoteAppLanguageBarSupported;
 
-               case FreeRDP_SurfaceCommandsEnabled:
-                       return settings->SurfaceCommandsEnabled;
+               case FreeRDP_RemoteApplicationMode:
+                       return settings->RemoteApplicationMode;
 
-               case FreeRDP_FrameMarkerCommandEnabled:
-                       return settings->FrameMarkerCommandEnabled;
+               case FreeRDP_RemoteAssistanceMode:
+                       return settings->RemoteAssistanceMode;
 
-               case FreeRDP_SurfaceFrameMarkerEnabled:
-                       return settings->SurfaceFrameMarkerEnabled;
+               case FreeRDP_RemoteAssistanceRequestControl:
+                       return settings->RemoteAssistanceRequestControl;
 
-               case FreeRDP_RemoteFxOnly:
-                       return settings->RemoteFxOnly;
+               case FreeRDP_RemoteConsoleAudio:
+                       return settings->RemoteConsoleAudio;
 
                case FreeRDP_RemoteFxCodec:
                        return settings->RemoteFxCodec;
@@ -408,99 +384,123 @@ BOOL freerdp_settings_get_bool(const rdpSettings* settings, size_t id)
                case FreeRDP_RemoteFxImageCodec:
                        return settings->RemoteFxImageCodec;
 
-               case FreeRDP_NSCodec:
-                       return settings->NSCodec;
+               case FreeRDP_RemoteFxOnly:
+                       return settings->RemoteFxOnly;
 
-               case FreeRDP_NSCodecAllowSubsampling:
-                       return settings->NSCodecAllowSubsampling;
+               case FreeRDP_RestrictedAdminModeRequired:
+                       return settings->RestrictedAdminModeRequired;
 
-               case FreeRDP_NSCodecAllowDynamicColorFidelity:
-                       return settings->NSCodecAllowDynamicColorFidelity;
+               case FreeRDP_SaltedChecksum:
+                       return settings->SaltedChecksum;
 
-               case FreeRDP_JpegCodec:
-                       return settings->JpegCodec;
-
-               case FreeRDP_GfxThinClient:
-                       return settings->GfxThinClient;
-
-               case FreeRDP_GfxSmallCache:
-                       return settings->GfxSmallCache;
-
-               case FreeRDP_GfxProgressive:
-                       return settings->GfxProgressive;
-
-               case FreeRDP_GfxProgressiveV2:
-                       return settings->GfxProgressiveV2;
-
-               case FreeRDP_GfxH264:
-                       return settings->GfxH264;
-
-               case FreeRDP_GfxAVC444:
-                       return settings->GfxAVC444;
-
-               case FreeRDP_GfxSendQoeAck:
-                       return settings->GfxSendQoeAck;
-
-               case FreeRDP_GfxAVC444v2:
-                       return settings->GfxAVC444v2;
-
-               case FreeRDP_DrawNineGridEnabled:
-                       return settings->DrawNineGridEnabled;
-
-               case FreeRDP_DrawGdiPlusEnabled:
-                       return settings->DrawGdiPlusEnabled;
-
-               case FreeRDP_DrawGdiPlusCacheEnabled:
-                       return settings->DrawGdiPlusCacheEnabled;
-
-               case FreeRDP_DeviceRedirection:
-                       return settings->DeviceRedirection;
+               case FreeRDP_SendPreconnectionPdu:
+                       return settings->SendPreconnectionPdu;
 
-               case FreeRDP_RedirectDrives:
-                       return settings->RedirectDrives;
+               case FreeRDP_ServerMode:
+                       return settings->ServerMode;
 
-               case FreeRDP_RedirectHomeDrive:
-                       return settings->RedirectHomeDrive;
+               case FreeRDP_SmartSizing:
+                       return settings->SmartSizing;
 
-               case FreeRDP_RedirectSmartCards:
-                       return settings->RedirectSmartCards;
+               case FreeRDP_SmartcardLogon:
+                       return settings->SmartcardLogon;
 
-               case FreeRDP_RedirectPrinters:
-                       return settings->RedirectPrinters;
+               case FreeRDP_SoftwareGdi:
+                       return settings->SoftwareGdi;
 
-               case FreeRDP_RedirectSerialPorts:
-                       return settings->RedirectSerialPorts;
+               case FreeRDP_SoundBeepsEnabled:
+                       return settings->SoundBeepsEnabled;
 
-               case FreeRDP_RedirectParallelPorts:
-                       return settings->RedirectParallelPorts;
+               case FreeRDP_SpanMonitors:
+                       return settings->SpanMonitors;
 
-               case FreeRDP_PreferIPv6OverIPv4:
-                       return settings->PreferIPv6OverIPv4;
+               case FreeRDP_SupportAsymetricKeys:
+                       return settings->SupportAsymetricKeys;
 
-               case FreeRDP_RedirectClipboard:
-                       return settings->RedirectClipboard;
+               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_SupportDisplayControl:
-                       return settings->SupportDisplayControl;
+               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_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_TcpKeepAlive:
                        return settings->TcpKeepAlive;
 
+               case FreeRDP_TlsSecurity:
+                       return settings->TlsSecurity;
+
+               case FreeRDP_ToggleFullscreen:
+                       return settings->ToggleFullscreen;
+
+               case FreeRDP_UnicodeInput:
+                       return settings->UnicodeInput;
+
+               case FreeRDP_UnmapButtons:
+                       return settings->UnmapButtons;
+
+               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, "[%s] Invalid key index %" PRIuz, __FUNCTION__, id);
                        return FALSE;
@@ -514,656 +514,656 @@ BOOL freerdp_settings_set_bool(rdpSettings* settings, size_t id, BOOL val)
 
        switch (id)
        {
-               case FreeRDP_ServerMode:
-                       settings->ServerMode = val;
+               case FreeRDP_AllowCacheWaitingList:
+                       settings->AllowCacheWaitingList = val;
                        break;
 
-               case FreeRDP_WaitForOutputBufferFlush:
-                       settings->WaitForOutputBufferFlush = val;
+               case FreeRDP_AllowDesktopComposition:
+                       settings->AllowDesktopComposition = val;
                        break;
 
-               case FreeRDP_NetworkAutoDetect:
-                       settings->NetworkAutoDetect = val;
+               case FreeRDP_AllowFontSmoothing:
+                       settings->AllowFontSmoothing = val;
                        break;
 
-               case FreeRDP_SupportAsymetricKeys:
-                       settings->SupportAsymetricKeys = val;
+               case FreeRDP_AllowUnanouncedOrdersFromServer:
+                       settings->AllowUnanouncedOrdersFromServer = val;
                        break;
 
-               case FreeRDP_SupportErrorInfoPdu:
-                       settings->SupportErrorInfoPdu = val;
+               case FreeRDP_AltSecFrameMarkerSupport:
+                       settings->AltSecFrameMarkerSupport = val;
                        break;
 
-               case FreeRDP_SupportStatusInfoPdu:
-                       settings->SupportStatusInfoPdu = val;
+               case FreeRDP_AsyncChannels:
+                       settings->AsyncChannels = val;
                        break;
 
-               case FreeRDP_SupportMonitorLayoutPdu:
-                       settings->SupportMonitorLayoutPdu = val;
+               case FreeRDP_AsyncInput:
+                       settings->AsyncInput = val;
                        break;
 
-               case FreeRDP_SupportGraphicsPipeline:
-                       settings->SupportGraphicsPipeline = val;
+               case FreeRDP_AsyncUpdate:
+                       settings->AsyncUpdate = val;
                        break;
 
-               case FreeRDP_SupportDynamicTimeZone:
-                       settings->SupportDynamicTimeZone = val;
+               case FreeRDP_AudioCapture:
+                       settings->AudioCapture = val;
                        break;
 
-               case FreeRDP_SupportHeartbeatPdu:
-                       settings->SupportHeartbeatPdu = val;
+               case FreeRDP_AudioPlayback:
+                       settings->AudioPlayback = val;
                        break;
 
-               case FreeRDP_UseRdpSecurityLayer:
-                       settings->UseRdpSecurityLayer = val;
+               case FreeRDP_Authentication:
+                       settings->Authentication = val;
                        break;
 
-               case FreeRDP_ConsoleSession:
-                       settings->ConsoleSession = val;
+               case FreeRDP_AuthenticationOnly:
+                       settings->AuthenticationOnly = val;
                        break;
 
-               case FreeRDP_SpanMonitors:
-                       settings->SpanMonitors = val;
+               case FreeRDP_AutoAcceptCertificate:
+                       settings->AutoAcceptCertificate = val;
                        break;
 
-               case FreeRDP_UseMultimon:
-                       settings->UseMultimon = val;
+               case FreeRDP_AutoDenyCertificate:
+                       settings->AutoDenyCertificate = val;
                        break;
 
-               case FreeRDP_ForceMultimon:
-                       settings->ForceMultimon = val;
+               case FreeRDP_AutoLogonEnabled:
+                       settings->AutoLogonEnabled = val;
                        break;
 
-               case FreeRDP_ListMonitors:
-                       settings->ListMonitors = val;
+               case FreeRDP_AutoReconnectionEnabled:
+                       settings->AutoReconnectionEnabled = val;
                        break;
 
-               case FreeRDP_HasMonitorAttributes:
-                       settings->HasMonitorAttributes = val;
+               case FreeRDP_BitmapCacheEnabled:
+                       settings->BitmapCacheEnabled = val;
                        break;
 
-               case FreeRDP_SupportMultitransport:
-                       settings->SupportMultitransport = val;
+               case FreeRDP_BitmapCachePersistEnabled:
+                       settings->BitmapCachePersistEnabled = val;
                        break;
 
-               case FreeRDP_AutoLogonEnabled:
-                       settings->AutoLogonEnabled = val;
+               case FreeRDP_BitmapCacheV3Enabled:
+                       settings->BitmapCacheV3Enabled = val;
                        break;
 
-               case FreeRDP_CompressionEnabled:
-                       settings->CompressionEnabled = val;
+               case FreeRDP_BitmapCompressionDisabled:
+                       settings->BitmapCompressionDisabled = val;
                        break;
 
-               case FreeRDP_DisableCtrlAltDel:
-                       settings->DisableCtrlAltDel = val;
+               case FreeRDP_ColorPointerFlag:
+                       settings->ColorPointerFlag = val;
                        break;
 
-               case FreeRDP_EnableWindowsKey:
-                       settings->EnableWindowsKey = val;
+               case FreeRDP_CompressionEnabled:
+                       settings->CompressionEnabled = val;
                        break;
 
-               case FreeRDP_MaximizeShell:
-                       settings->MaximizeShell = val;
+               case FreeRDP_ConsoleSession:
+                       settings->ConsoleSession = val;
                        break;
 
-               case FreeRDP_LogonNotify:
-                       settings->LogonNotify = val;
+               case FreeRDP_CredentialsFromStdin:
+                       settings->CredentialsFromStdin = val;
                        break;
 
-               case FreeRDP_LogonErrors:
-                       settings->LogonErrors = val;
+               case FreeRDP_Decorations:
+                       settings->Decorations = val;
                        break;
 
-               case FreeRDP_MouseAttached:
-                       settings->MouseAttached = val;
+               case FreeRDP_DesktopResize:
+                       settings->DesktopResize = val;
                        break;
 
-               case FreeRDP_MouseHasWheel:
-                       settings->MouseHasWheel = val;
+               case FreeRDP_DeviceRedirection:
+                       settings->DeviceRedirection = val;
                        break;
 
-               case FreeRDP_RemoteConsoleAudio:
-                       settings->RemoteConsoleAudio = val;
+               case FreeRDP_DisableCredentialsDelegation:
+                       settings->DisableCredentialsDelegation = val;
                        break;
 
-               case FreeRDP_AudioPlayback:
-                       settings->AudioPlayback = val;
+               case FreeRDP_DisableCtrlAltDel:
+                       settings->DisableCtrlAltDel = val;
                        break;
 
-               case FreeRDP_AudioCapture:
-                       settings->AudioCapture = val;
+               case FreeRDP_DisableCursorBlinking:
+                       settings->DisableCursorBlinking = val;
                        break;
 
-               case FreeRDP_VideoDisable:
-                       settings->VideoDisable = val;
-                       break;
-
-               case FreeRDP_PasswordIsSmartcardPin:
-                       settings->PasswordIsSmartcardPin = val;
+               case FreeRDP_DisableCursorShadow:
+                       settings->DisableCursorShadow = val;
                        break;
 
-               case FreeRDP_UsingSavedCredentials:
-                       settings->UsingSavedCredentials = val;
+               case FreeRDP_DisableFullWindowDrag:
+                       settings->DisableFullWindowDrag = val;
                        break;
 
-               case FreeRDP_ForceEncryptedCsPdu:
-                       settings->ForceEncryptedCsPdu = val;
+               case FreeRDP_DisableMenuAnims:
+                       settings->DisableMenuAnims = val;
                        break;
 
-               case FreeRDP_HiDefRemoteApp:
-                       settings->HiDefRemoteApp = val;
+               case FreeRDP_DisableRemoteAppCapsCheck:
+                       settings->DisableRemoteAppCapsCheck = val;
                        break;
 
-               case FreeRDP_IPv6Enabled:
-                       settings->IPv6Enabled = val;
+               case FreeRDP_DisableThemes:
+                       settings->DisableThemes = val;
                        break;
 
-               case FreeRDP_AutoReconnectionEnabled:
-                       settings->AutoReconnectionEnabled = val;
+               case FreeRDP_DisableWallpaper:
+                       settings->DisableWallpaper = val;
                        break;
 
-               case FreeRDP_PrintReconnectCookie:
-                       settings->PrintReconnectCookie = val;
+               case FreeRDP_DrawAllowColorSubsampling:
+                       settings->DrawAllowColorSubsampling = val;
                        break;
 
-               case FreeRDP_DynamicDaylightTimeDisabled:
-                       settings->DynamicDaylightTimeDisabled = val;
+               case FreeRDP_DrawAllowDynamicColorFidelity:
+                       settings->DrawAllowDynamicColorFidelity = val;
                        break;
 
-               case FreeRDP_AllowFontSmoothing:
-                       settings->AllowFontSmoothing = val;
+               case FreeRDP_DrawAllowSkipAlpha:
+                       settings->DrawAllowSkipAlpha = val;
                        break;
 
-               case FreeRDP_DisableWallpaper:
-                       settings->DisableWallpaper = val;
+               case FreeRDP_DrawGdiPlusCacheEnabled:
+                       settings->DrawGdiPlusCacheEnabled = val;
                        break;
 
-               case FreeRDP_DisableFullWindowDrag:
-                       settings->DisableFullWindowDrag = val;
+               case FreeRDP_DrawGdiPlusEnabled:
+                       settings->DrawGdiPlusEnabled = val;
                        break;
 
-               case FreeRDP_DisableMenuAnims:
-                       settings->DisableMenuAnims = val;
+               case FreeRDP_DrawNineGridEnabled:
+                       settings->DrawNineGridEnabled = val;
                        break;
 
-               case FreeRDP_DisableThemes:
-                       settings->DisableThemes = val;
+               case FreeRDP_DumpRemoteFx:
+                       settings->DumpRemoteFx = val;
                        break;
 
-               case FreeRDP_DisableCursorShadow:
-                       settings->DisableCursorShadow = val;
+               case FreeRDP_DynamicDaylightTimeDisabled:
+                       settings->DynamicDaylightTimeDisabled = val;
                        break;
 
-               case FreeRDP_DisableCursorBlinking:
-                       settings->DisableCursorBlinking = val;
+               case FreeRDP_DynamicResolutionUpdate:
+                       settings->DynamicResolutionUpdate = val;
                        break;
 
-               case FreeRDP_AllowDesktopComposition:
-                       settings->AllowDesktopComposition = val;
+               case FreeRDP_EmbeddedWindow:
+                       settings->EmbeddedWindow = val;
                        break;
 
-               case FreeRDP_RemoteAssistanceMode:
-                       settings->RemoteAssistanceMode = val;
+               case FreeRDP_EnableWindowsKey:
+                       settings->EnableWindowsKey = val;
                        break;
 
                case FreeRDP_EncomspVirtualChannel:
                        settings->EncomspVirtualChannel = val;
                        break;
 
-               case FreeRDP_RemdeskVirtualChannel:
-                       settings->RemdeskVirtualChannel = val;
+               case FreeRDP_ExtSecurity:
+                       settings->ExtSecurity = val;
                        break;
 
-               case FreeRDP_LyncRdpMode:
-                       settings->LyncRdpMode = val;
+               case FreeRDP_ExternalCertificateManagement:
+                       settings->ExternalCertificateManagement = val;
                        break;
 
-               case FreeRDP_RemoteAssistanceRequestControl:
-                       settings->RemoteAssistanceRequestControl = val;
+               case FreeRDP_FIPSMode:
+                       settings->FIPSMode = val;
                        break;
 
-               case FreeRDP_TlsSecurity:
-                       settings->TlsSecurity = val;
+               case FreeRDP_FastPathInput:
+                       settings->FastPathInput = val;
                        break;
 
-               case FreeRDP_NlaSecurity:
-                       settings->NlaSecurity = val;
+               case FreeRDP_FastPathOutput:
+                       settings->FastPathOutput = val;
                        break;
 
-               case FreeRDP_RdpSecurity:
-                       settings->RdpSecurity = val;
+               case FreeRDP_ForceEncryptedCsPdu:
+                       settings->ForceEncryptedCsPdu = val;
                        break;
 
-               case FreeRDP_ExtSecurity:
-                       settings->ExtSecurity = val;
+               case FreeRDP_ForceMultimon:
+                       settings->ForceMultimon = val;
                        break;
 
-               case FreeRDP_Authentication:
-                       settings->Authentication = val;
+               case FreeRDP_FrameMarkerCommandEnabled:
+                       settings->FrameMarkerCommandEnabled = val;
                        break;
 
-               case FreeRDP_NegotiateSecurityLayer:
-                       settings->NegotiateSecurityLayer = val;
+               case FreeRDP_Fullscreen:
+                       settings->Fullscreen = val;
                        break;
 
-               case FreeRDP_RestrictedAdminModeRequired:
-                       settings->RestrictedAdminModeRequired = val;
+               case FreeRDP_GatewayBypassLocal:
+                       settings->GatewayBypassLocal = val;
                        break;
 
-               case FreeRDP_DisableCredentialsDelegation:
-                       settings->DisableCredentialsDelegation = val;
+               case FreeRDP_GatewayEnabled:
+                       settings->GatewayEnabled = val;
                        break;
 
-               case FreeRDP_VmConnectMode:
-                       settings->VmConnectMode = val;
+               case FreeRDP_GatewayHttpTransport:
+                       settings->GatewayHttpTransport = val;
                        break;
 
-               case FreeRDP_FIPSMode:
-                       settings->FIPSMode = val;
+               case FreeRDP_GatewayRpcTransport:
+                       settings->GatewayRpcTransport = val;
                        break;
 
-               case FreeRDP_MstscCookieMode:
-                       settings->MstscCookieMode = val;
+               case FreeRDP_GatewayUdpTransport:
+                       settings->GatewayUdpTransport = val;
                        break;
 
-               case FreeRDP_SendPreconnectionPdu:
-                       settings->SendPreconnectionPdu = val;
+               case FreeRDP_GatewayUseSameCredentials:
+                       settings->GatewayUseSameCredentials = val;
                        break;
 
-               case FreeRDP_SmartcardLogon:
-                       settings->SmartcardLogon = val;
+               case FreeRDP_GfxAVC444:
+                       settings->GfxAVC444 = val;
                        break;
 
-               case FreeRDP_PromptForCredentials:
-                       settings->PromptForCredentials = val;
+               case FreeRDP_GfxAVC444v2:
+                       settings->GfxAVC444v2 = val;
                        break;
 
-               case FreeRDP_IgnoreCertificate:
-                       settings->IgnoreCertificate = val;
+               case FreeRDP_GfxH264:
+                       settings->GfxH264 = val;
                        break;
 
-               case FreeRDP_ExternalCertificateManagement:
-                       settings->ExternalCertificateManagement = val;
+               case FreeRDP_GfxProgressive:
+                       settings->GfxProgressive = val;
                        break;
 
-               case FreeRDP_AutoAcceptCertificate:
-                       settings->AutoAcceptCertificate = val;
+               case FreeRDP_GfxProgressiveV2:
+                       settings->GfxProgressiveV2 = val;
                        break;
 
-               case FreeRDP_AutoDenyCertificate:
-                       settings->AutoDenyCertificate = val;
+               case FreeRDP_GfxSendQoeAck:
+                       settings->GfxSendQoeAck = val;
                        break;
 
-               case FreeRDP_Workarea:
-                       settings->Workarea = val;
+               case FreeRDP_GfxSmallCache:
+                       settings->GfxSmallCache = val;
                        break;
 
-               case FreeRDP_Fullscreen:
-                       settings->Fullscreen = val;
+               case FreeRDP_GfxThinClient:
+                       settings->GfxThinClient = val;
                        break;
 
                case FreeRDP_GrabKeyboard:
                        settings->GrabKeyboard = val;
                        break;
 
-               case FreeRDP_Decorations:
-                       settings->Decorations = val;
+               case FreeRDP_HasExtendedMouseEvent:
+                       settings->HasExtendedMouseEvent = val;
                        break;
 
-               case FreeRDP_MouseMotion:
-                       settings->MouseMotion = val;
+               case FreeRDP_HasHorizontalWheel:
+                       settings->HasHorizontalWheel = val;
                        break;
 
-               case FreeRDP_AsyncInput:
-                       settings->AsyncInput = val;
+               case FreeRDP_HasMonitorAttributes:
+                       settings->HasMonitorAttributes = val;
                        break;
 
-               case FreeRDP_AsyncUpdate:
-                       settings->AsyncUpdate = val;
+               case FreeRDP_HiDefRemoteApp:
+                       settings->HiDefRemoteApp = val;
                        break;
 
-               case FreeRDP_AsyncChannels:
-                       settings->AsyncChannels = val;
+               case FreeRDP_IPv6Enabled:
+                       settings->IPv6Enabled = val;
                        break;
 
-               case FreeRDP_ToggleFullscreen:
-                       settings->ToggleFullscreen = val;
+               case FreeRDP_IgnoreCertificate:
+                       settings->IgnoreCertificate = val;
                        break;
 
-               case FreeRDP_EmbeddedWindow:
-                       settings->EmbeddedWindow = val;
+               case FreeRDP_JpegCodec:
+                       settings->JpegCodec = val;
                        break;
 
-               case FreeRDP_SmartSizing:
-                       settings->SmartSizing = val;
+               case FreeRDP_ListMonitors:
+                       settings->ListMonitors = val;
                        break;
 
-               case FreeRDP_PercentScreenUseWidth:
-                       settings->PercentScreenUseWidth = val;
+               case FreeRDP_LocalConnection:
+                       settings->LocalConnection = val;
                        break;
 
-               case FreeRDP_PercentScreenUseHeight:
-                       settings->PercentScreenUseHeight = val;
+               case FreeRDP_LogonErrors:
+                       settings->LogonErrors = val;
                        break;
 
-               case FreeRDP_DynamicResolutionUpdate:
-                       settings->DynamicResolutionUpdate = val;
+               case FreeRDP_LogonNotify:
+                       settings->LogonNotify = val;
                        break;
 
-               case FreeRDP_SoftwareGdi:
-                       settings->SoftwareGdi = val;
+               case FreeRDP_LongCredentialsSupported:
+                       settings->LongCredentialsSupported = val;
                        break;
 
-               case FreeRDP_LocalConnection:
-                       settings->LocalConnection = val;
+               case FreeRDP_LyncRdpMode:
+                       settings->LyncRdpMode = val;
                        break;
 
-               case FreeRDP_AuthenticationOnly:
-                       settings->AuthenticationOnly = val;
+               case FreeRDP_MaximizeShell:
+                       settings->MaximizeShell = val;
                        break;
 
-               case FreeRDP_CredentialsFromStdin:
-                       settings->CredentialsFromStdin = val;
+               case FreeRDP_MouseAttached:
+                       settings->MouseAttached = val;
                        break;
 
-               case FreeRDP_UnmapButtons:
-                       settings->UnmapButtons = val;
+               case FreeRDP_MouseHasWheel:
+                       settings->MouseHasWheel = val;
                        break;
 
-               case FreeRDP_OldLicenseBehaviour:
-                       settings->OldLicenseBehaviour = val;
+               case FreeRDP_MouseMotion:
+                       settings->MouseMotion = val;
                        break;
 
-               case FreeRDP_DumpRemoteFx:
-                       settings->DumpRemoteFx = val;
+               case FreeRDP_MstscCookieMode:
+                       settings->MstscCookieMode = val;
                        break;
 
-               case FreeRDP_PlayRemoteFx:
-                       settings->PlayRemoteFx = val;
+               case FreeRDP_MultiTouchGestures:
+                       settings->MultiTouchGestures = val;
                        break;
 
-               case FreeRDP_GatewayUseSameCredentials:
-                       settings->GatewayUseSameCredentials = val;
+               case FreeRDP_MultiTouchInput:
+                       settings->MultiTouchInput = val;
                        break;
 
-               case FreeRDP_GatewayEnabled:
-                       settings->GatewayEnabled = val;
+               case FreeRDP_NSCodec:
+                       settings->NSCodec = val;
                        break;
 
-               case FreeRDP_GatewayBypassLocal:
-                       settings->GatewayBypassLocal = val;
+               case FreeRDP_NSCodecAllowDynamicColorFidelity:
+                       settings->NSCodecAllowDynamicColorFidelity = val;
                        break;
 
-               case FreeRDP_GatewayRpcTransport:
-                       settings->GatewayRpcTransport = val;
+               case FreeRDP_NSCodecAllowSubsampling:
+                       settings->NSCodecAllowSubsampling = val;
                        break;
 
-               case FreeRDP_GatewayHttpTransport:
-                       settings->GatewayHttpTransport = val;
+               case FreeRDP_NegotiateSecurityLayer:
+                       settings->NegotiateSecurityLayer = val;
                        break;
 
-               case FreeRDP_GatewayUdpTransport:
-                       settings->GatewayUdpTransport = val;
+               case FreeRDP_NetworkAutoDetect:
+                       settings->NetworkAutoDetect = val;
                        break;
 
-               case FreeRDP_RemoteApplicationMode:
-                       settings->RemoteApplicationMode = val;
+               case FreeRDP_NlaSecurity:
+                       settings->NlaSecurity = val;
                        break;
 
-               case FreeRDP_DisableRemoteAppCapsCheck:
-                       settings->DisableRemoteAppCapsCheck = val;
+               case FreeRDP_NoBitmapCompressionHeader:
+                       settings->NoBitmapCompressionHeader = val;
                        break;
 
-               case FreeRDP_RemoteAppLanguageBarSupported:
-                       settings->RemoteAppLanguageBarSupported = val;
+               case FreeRDP_OldLicenseBehaviour:
+                       settings->OldLicenseBehaviour = val;
                        break;
 
-               case FreeRDP_RefreshRect:
-                       settings->RefreshRect = val;
+               case FreeRDP_PasswordIsSmartcardPin:
+                       settings->PasswordIsSmartcardPin = val;
                        break;
 
-               case FreeRDP_SuppressOutput:
-                       settings->SuppressOutput = val;
+               case FreeRDP_PercentScreenUseHeight:
+                       settings->PercentScreenUseHeight = val;
                        break;
 
-               case FreeRDP_FastPathOutput:
-                       settings->FastPathOutput = val;
+               case FreeRDP_PercentScreenUseWidth:
+                       settings->PercentScreenUseWidth = val;
                        break;
 
-               case FreeRDP_SaltedChecksum:
-                       settings->SaltedChecksum = val;
+               case FreeRDP_PlayRemoteFx:
+                       settings->PlayRemoteFx = val;
                        break;
 
-               case FreeRDP_LongCredentialsSupported:
-                       settings->LongCredentialsSupported = val;
+               case FreeRDP_PreferIPv6OverIPv4:
+                       settings->PreferIPv6OverIPv4 = val;
                        break;
 
-               case FreeRDP_NoBitmapCompressionHeader:
-                       settings->NoBitmapCompressionHeader = val;
+               case FreeRDP_PrintReconnectCookie:
+                       settings->PrintReconnectCookie = val;
                        break;
 
-               case FreeRDP_BitmapCompressionDisabled:
-                       settings->BitmapCompressionDisabled = val;
+               case FreeRDP_PromptForCredentials:
+                       settings->PromptForCredentials = val;
                        break;
 
-               case FreeRDP_DesktopResize:
-                       settings->DesktopResize = val;
+               case FreeRDP_RdpSecurity:
+                       settings->RdpSecurity = val;
                        break;
 
-               case FreeRDP_DrawAllowDynamicColorFidelity:
-                       settings->DrawAllowDynamicColorFidelity = val;
+               case FreeRDP_RedirectClipboard:
+                       settings->RedirectClipboard = val;
                        break;
 
-               case FreeRDP_DrawAllowColorSubsampling:
-                       settings->DrawAllowColorSubsampling = val;
+               case FreeRDP_RedirectDrives:
+                       settings->RedirectDrives = val;
                        break;
 
-               case FreeRDP_DrawAllowSkipAlpha:
-                       settings->DrawAllowSkipAlpha = val;
+               case FreeRDP_RedirectHomeDrive:
+                       settings->RedirectHomeDrive = val;
                        break;
 
-               case FreeRDP_BitmapCacheV3Enabled:
-                       settings->BitmapCacheV3Enabled = val;
+               case FreeRDP_RedirectParallelPorts:
+                       settings->RedirectParallelPorts = val;
                        break;
 
-               case FreeRDP_AltSecFrameMarkerSupport:
-                       settings->AltSecFrameMarkerSupport = val;
+               case FreeRDP_RedirectPrinters:
+                       settings->RedirectPrinters = val;
                        break;
 
-               case FreeRDP_AllowUnanouncedOrdersFromServer:
-                       settings->AllowUnanouncedOrdersFromServer = val;
+               case FreeRDP_RedirectSerialPorts:
+                       settings->RedirectSerialPorts = val;
                        break;
 
-               case FreeRDP_BitmapCacheEnabled:
-                       settings->BitmapCacheEnabled = val;
+               case FreeRDP_RedirectSmartCards:
+                       settings->RedirectSmartCards = val;
                        break;
 
-               case FreeRDP_AllowCacheWaitingList:
-                       settings->AllowCacheWaitingList = val;
+               case FreeRDP_RefreshRect:
+                       settings->RefreshRect = val;
                        break;
 
-               case FreeRDP_BitmapCachePersistEnabled:
-                       settings->BitmapCachePersistEnabled = val;
+               case FreeRDP_RemdeskVirtualChannel:
+                       settings->RemdeskVirtualChannel = val;
                        break;
 
-               case FreeRDP_ColorPointerFlag:
-                       settings->ColorPointerFlag = val;
+               case FreeRDP_RemoteAppLanguageBarSupported:
+                       settings->RemoteAppLanguageBarSupported = val;
                        break;
 
-               case FreeRDP_UnicodeInput:
-                       settings->UnicodeInput = val;
+               case FreeRDP_RemoteApplicationMode:
+                       settings->RemoteApplicationMode = val;
                        break;
 
-               case FreeRDP_FastPathInput:
-                       settings->FastPathInput = val;
+               case FreeRDP_RemoteAssistanceMode:
+                       settings->RemoteAssistanceMode = val;
                        break;
 
-               case FreeRDP_MultiTouchInput:
-                       settings->MultiTouchInput = val;
+               case FreeRDP_RemoteAssistanceRequestControl:
+                       settings->RemoteAssistanceRequestControl = val;
                        break;
 
-               case FreeRDP_MultiTouchGestures:
-                       settings->MultiTouchGestures = val;
+               case FreeRDP_RemoteConsoleAudio:
+                       settings->RemoteConsoleAudio = val;
                        break;
 
-               case FreeRDP_HasHorizontalWheel:
-                       settings->HasHorizontalWheel = val;
+               case FreeRDP_RemoteFxCodec:
+                       settings->RemoteFxCodec = val;
                        break;
 
-               case FreeRDP_HasExtendedMouseEvent:
-                       settings->HasExtendedMouseEvent = val;
+               case FreeRDP_RemoteFxImageCodec:
+                       settings->RemoteFxImageCodec = val;
                        break;
 
-               case FreeRDP_SoundBeepsEnabled:
-                       settings->SoundBeepsEnabled = val;
+               case FreeRDP_RemoteFxOnly:
+                       settings->RemoteFxOnly = val;
                        break;
 
-               case FreeRDP_SurfaceCommandsEnabled:
-                       settings->SurfaceCommandsEnabled = val;
+               case FreeRDP_RestrictedAdminModeRequired:
+                       settings->RestrictedAdminModeRequired = val;
                        break;
 
-               case FreeRDP_FrameMarkerCommandEnabled:
-                       settings->FrameMarkerCommandEnabled = val;
+               case FreeRDP_SaltedChecksum:
+                       settings->SaltedChecksum = val;
                        break;
 
-               case FreeRDP_SurfaceFrameMarkerEnabled:
-                       settings->SurfaceFrameMarkerEnabled = val;
+               case FreeRDP_SendPreconnectionPdu:
+                       settings->SendPreconnectionPdu = val;
                        break;
 
-               case FreeRDP_RemoteFxOnly:
-                       settings->RemoteFxOnly = val;
+               case FreeRDP_ServerMode:
+                       settings->ServerMode = val;
                        break;
 
-               case FreeRDP_RemoteFxCodec:
-                       settings->RemoteFxCodec = val;
+               case FreeRDP_SmartSizing:
+                       settings->SmartSizing = val;
                        break;
 
-               case FreeRDP_RemoteFxImageCodec:
-                       settings->RemoteFxImageCodec = val;
+               case FreeRDP_SmartcardLogon:
+                       settings->SmartcardLogon = val;
                        break;
 
-               case FreeRDP_NSCodec:
-                       settings->NSCodec = val;
+               case FreeRDP_SoftwareGdi:
+                       settings->SoftwareGdi = val;
                        break;
 
-               case FreeRDP_NSCodecAllowSubsampling:
-                       settings->NSCodecAllowSubsampling = val;
+               case FreeRDP_SoundBeepsEnabled:
+                       settings->SoundBeepsEnabled = val;
                        break;
 
-               case FreeRDP_NSCodecAllowDynamicColorFidelity:
-                       settings->NSCodecAllowDynamicColorFidelity = val;
+               case FreeRDP_SpanMonitors:
+                       settings->SpanMonitors = val;
                        break;
 
-               case FreeRDP_JpegCodec:
-                       settings->JpegCodec = val;
+               case FreeRDP_SupportAsymetricKeys:
+                       settings->SupportAsymetricKeys = val;
                        break;
 
-               case FreeRDP_GfxThinClient:
-                       settings->GfxThinClient = val;
+               case FreeRDP_SupportDisplayControl:
+                       settings->SupportDisplayControl = val;
                        break;
 
-               case FreeRDP_GfxSmallCache:
-                       settings->GfxSmallCache = val;
+               case FreeRDP_SupportDynamicChannels:
+                       settings->SupportDynamicChannels = val;
                        break;
 
-               case FreeRDP_GfxProgressive:
-                       settings->GfxProgressive = val;
+               case FreeRDP_SupportDynamicTimeZone:
+                       settings->SupportDynamicTimeZone = val;
                        break;
 
-               case FreeRDP_GfxProgressiveV2:
-                       settings->GfxProgressiveV2 = val;
+               case FreeRDP_SupportEchoChannel:
+                       settings->SupportEchoChannel = val;
                        break;
 
-               case FreeRDP_GfxH264:
-                       settings->GfxH264 = val;
+               case FreeRDP_SupportErrorInfoPdu:
+                       settings->SupportErrorInfoPdu = val;
                        break;
 
-               case FreeRDP_GfxAVC444:
-                       settings->GfxAVC444 = val;
+               case FreeRDP_SupportGeometryTracking:
+                       settings->SupportGeometryTracking = val;
                        break;
 
-               case FreeRDP_GfxSendQoeAck:
-                       settings->GfxSendQoeAck = val;
+               case FreeRDP_SupportGraphicsPipeline:
+                       settings->SupportGraphicsPipeline = val;
                        break;
 
-               case FreeRDP_GfxAVC444v2:
-                       settings->GfxAVC444v2 = val;
+               case FreeRDP_SupportHeartbeatPdu:
+                       settings->SupportHeartbeatPdu = val;
                        break;
 
-               case FreeRDP_DrawNineGridEnabled:
-                       settings->DrawNineGridEnabled = val;
+               case FreeRDP_SupportMonitorLayoutPdu:
+                       settings->SupportMonitorLayoutPdu = val;
                        break;
 
-               case FreeRDP_DrawGdiPlusEnabled:
-                       settings->DrawGdiPlusEnabled = val;
+               case FreeRDP_SupportMultitransport:
+                       settings->SupportMultitransport = val;
                        break;
 
-               case FreeRDP_DrawGdiPlusCacheEnabled:
-                       settings->DrawGdiPlusCacheEnabled = val;
+               case FreeRDP_SupportSSHAgentChannel:
+                       settings->SupportSSHAgentChannel = val;
                        break;
 
-               case FreeRDP_DeviceRedirection:
-                       settings->DeviceRedirection = val;
+               case FreeRDP_SupportStatusInfoPdu:
+                       settings->SupportStatusInfoPdu = val;
                        break;
 
-               case FreeRDP_RedirectDrives:
-                       settings->RedirectDrives = val;
+               case FreeRDP_SupportVideoOptimized:
+                       settings->SupportVideoOptimized = val;
                        break;
 
-               case FreeRDP_RedirectHomeDrive:
-                       settings->RedirectHomeDrive = val;
+               case FreeRDP_SuppressOutput:
+                       settings->SuppressOutput = val;
                        break;
 
-               case FreeRDP_RedirectSmartCards:
-                       settings->RedirectSmartCards = val;
+               case FreeRDP_SurfaceCommandsEnabled:
+                       settings->SurfaceCommandsEnabled = val;
                        break;
 
-               case FreeRDP_RedirectPrinters:
-                       settings->RedirectPrinters = val;
+               case FreeRDP_SurfaceFrameMarkerEnabled:
+                       settings->SurfaceFrameMarkerEnabled = val;
                        break;
 
-               case FreeRDP_RedirectSerialPorts:
-                       settings->RedirectSerialPorts = val;
+               case FreeRDP_TcpKeepAlive:
+                       settings->TcpKeepAlive = val;
                        break;
 
-               case FreeRDP_RedirectParallelPorts:
-                       settings->RedirectParallelPorts = val;
+               case FreeRDP_TlsSecurity:
+                       settings->TlsSecurity = val;
                        break;
 
-               case FreeRDP_PreferIPv6OverIPv4:
-                       settings->PreferIPv6OverIPv4 = val;
+               case FreeRDP_ToggleFullscreen:
+                       settings->ToggleFullscreen = val;
                        break;
 
-               case FreeRDP_RedirectClipboard:
-                       settings->RedirectClipboard = val;
+               case FreeRDP_UnicodeInput:
+                       settings->UnicodeInput = val;
                        break;
 
-               case FreeRDP_SupportDynamicChannels:
-                       settings->SupportDynamicChannels = val;
+               case FreeRDP_UnmapButtons:
+                       settings->UnmapButtons = val;
                        break;
 
-               case FreeRDP_SupportEchoChannel:
-                       settings->SupportEchoChannel = val;
+               case FreeRDP_UseMultimon:
+                       settings->UseMultimon = val;
                        break;
 
-               case FreeRDP_SupportDisplayControl:
-                       settings->SupportDisplayControl = val;
+               case FreeRDP_UseRdpSecurityLayer:
+                       settings->UseRdpSecurityLayer = val;
                        break;
 
-               case FreeRDP_SupportGeometryTracking:
-                       settings->SupportGeometryTracking = val;
+               case FreeRDP_UsingSavedCredentials:
+                       settings->UsingSavedCredentials = val;
                        break;
 
-               case FreeRDP_SupportSSHAgentChannel:
-                       settings->SupportSSHAgentChannel = val;
+               case FreeRDP_VideoDisable:
+                       settings->VideoDisable = val;
                        break;
 
-               case FreeRDP_SupportVideoOptimized:
-                       settings->SupportVideoOptimized = val;
+               case FreeRDP_VmConnectMode:
+                       settings->VmConnectMode = val;
                        break;
 
-               case FreeRDP_TcpKeepAlive:
-                       settings->TcpKeepAlive = val;
+               case FreeRDP_WaitForOutputBufferFlush:
+                       settings->WaitForOutputBufferFlush = val;
+                       break;
+
+               case FreeRDP_Workarea:
+                       settings->Workarea = val;
                        break;
 
                default:
@@ -1248,83 +1248,164 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id)
 
        switch (id)
        {
-               case FreeRDP_ShareId:
-                       return settings->ShareId;
+               case FreeRDP_AcceptedCertLength:
+                       return settings->AcceptedCertLength;
 
-               case FreeRDP_PduSource:
-                       return settings->PduSource;
+               case FreeRDP_AuthenticationLevel:
+                       return settings->AuthenticationLevel;
 
-               case FreeRDP_ServerPort:
-                       return settings->ServerPort;
+               case FreeRDP_AutoReconnectMaxRetries:
+                       return settings->AutoReconnectMaxRetries;
 
-               case FreeRDP_MaxTimeInCheckLoop:
-                       return settings->MaxTimeInCheckLoop;
+               case FreeRDP_BitmapCacheV2NumCells:
+                       return settings->BitmapCacheV2NumCells;
 
-               case FreeRDP_AcceptedCertLength:
-                       return settings->AcceptedCertLength;
+               case FreeRDP_BitmapCacheV3CodecId:
+                       return settings->BitmapCacheV3CodecId;
 
-               case FreeRDP_RdpVersion:
-                       return settings->RdpVersion;
+               case FreeRDP_BitmapCacheVersion:
+                       return settings->BitmapCacheVersion;
 
-               case FreeRDP_DesktopWidth:
-                       return settings->DesktopWidth;
+               case FreeRDP_BrushSupportLevel:
+                       return settings->BrushSupportLevel;
 
-               case FreeRDP_DesktopHeight:
-                       return settings->DesktopHeight;
+               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_ClusterInfoFlags:
+                       return settings->ClusterInfoFlags;
 
                case FreeRDP_ColorDepth:
                        return settings->ColorDepth;
 
+               case FreeRDP_CompDeskSupportLevel:
+                       return settings->CompDeskSupportLevel;
+
+               case FreeRDP_CompressionLevel:
+                       return settings->CompressionLevel;
+
                case FreeRDP_ConnectionType:
                        return settings->ConnectionType;
 
-               case FreeRDP_ClientBuild:
-                       return settings->ClientBuild;
+               case FreeRDP_CookieMaxLength:
+                       return settings->CookieMaxLength;
 
-               case FreeRDP_EarlyCapabilityFlags:
-                       return settings->EarlyCapabilityFlags;
+               case FreeRDP_DesktopHeight:
+                       return settings->DesktopHeight;
+
+               case FreeRDP_DesktopPhysicalHeight:
+                       return settings->DesktopPhysicalHeight;
 
                case FreeRDP_DesktopPhysicalWidth:
                        return settings->DesktopPhysicalWidth;
 
-               case FreeRDP_DesktopPhysicalHeight:
-                       return settings->DesktopPhysicalHeight;
+               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_EncryptionLevel:
-                       return settings->EncryptionLevel;
+               case FreeRDP_FrameAcknowledge:
+                       return settings->FrameAcknowledge;
 
-               case FreeRDP_ServerRandomLength:
-                       return settings->ServerRandomLength;
+               case FreeRDP_GatewayAcceptedCertLength:
+                       return settings->GatewayAcceptedCertLength;
 
-               case FreeRDP_ServerCertificateLength:
-                       return settings->ServerCertificateLength;
+               case FreeRDP_GatewayCredentialsSource:
+                       return settings->GatewayCredentialsSource;
 
-               case FreeRDP_ClientRandomLength:
-                       return settings->ClientRandomLength;
+               case FreeRDP_GatewayPort:
+                       return settings->GatewayPort;
 
-               case FreeRDP_ChannelCount:
-                       return settings->ChannelCount;
+               case FreeRDP_GatewayUsageMethod:
+                       return settings->GatewayUsageMethod;
 
-               case FreeRDP_ChannelDefArraySize:
-                       return settings->ChannelDefArraySize;
+               case FreeRDP_GfxCapsFilter:
+                       return settings->GfxCapsFilter;
 
-               case FreeRDP_ClusterInfoFlags:
-                       return settings->ClusterInfoFlags;
+               case FreeRDP_GlyphSupportLevel:
+                       return settings->GlyphSupportLevel;
 
-               case FreeRDP_RedirectedSessionId:
-                       return settings->RedirectedSessionId;
+               case FreeRDP_JpegCodecId:
+                       return settings->JpegCodecId;
+
+               case FreeRDP_JpegQuality:
+                       return settings->JpegQuality;
+
+               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_MaxTimeInCheckLoop:
+                       return settings->MaxTimeInCheckLoop;
 
                case FreeRDP_MonitorCount:
                        return settings->MonitorCount;
@@ -1332,188 +1413,110 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id)
                case FreeRDP_MonitorDefArraySize:
                        return settings->MonitorDefArraySize;
 
-               case FreeRDP_DesktopPosX:
-                       return settings->DesktopPosX;
-
-               case FreeRDP_DesktopPosY:
-                       return settings->DesktopPosY;
-
-               case FreeRDP_NumMonitorIds:
-                       return settings->NumMonitorIds;
-
                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_CompressionLevel:
-                       return settings->CompressionLevel;
-
-               case FreeRDP_AutoReconnectMaxRetries:
-                       return settings->AutoReconnectMaxRetries;
-
-               case FreeRDP_PerformanceFlags:
-                       return settings->PerformanceFlags;
-
-               case FreeRDP_RequestedProtocols:
-                       return settings->RequestedProtocols;
+               case FreeRDP_NSCodecColorLossLevel:
+                       return settings->NSCodecColorLossLevel;
 
-               case FreeRDP_SelectedProtocol:
-                       return settings->SelectedProtocol;
+               case FreeRDP_NSCodecId:
+                       return settings->NSCodecId;
 
                case FreeRDP_NegotiationFlags:
                        return settings->NegotiationFlags;
 
-               case FreeRDP_AuthenticationLevel:
-                       return settings->AuthenticationLevel;
-
-               case FreeRDP_TlsSecLevel:
-                       return settings->TlsSecLevel;
-
-               case FreeRDP_CookieMaxLength:
-                       return settings->CookieMaxLength;
-
-               case FreeRDP_PreconnectionId:
-                       return settings->PreconnectionId;
-
-               case FreeRDP_RedirectionFlags:
-                       return settings->RedirectionFlags;
-
-               case FreeRDP_LoadBalanceInfoLength:
-                       return settings->LoadBalanceInfoLength;
+               case FreeRDP_NumMonitorIds:
+                       return settings->NumMonitorIds;
 
-               case FreeRDP_RedirectionPasswordLength:
-                       return settings->RedirectionPasswordLength;
+               case FreeRDP_OffscreenCacheEntries:
+                       return settings->OffscreenCacheEntries;
 
-               case FreeRDP_RedirectionTsvUrlLength:
-                       return settings->RedirectionTsvUrlLength;
+               case FreeRDP_OffscreenCacheSize:
+                       return settings->OffscreenCacheSize;
 
-               case FreeRDP_TargetNetAddressCount:
-                       return settings->TargetNetAddressCount;
+               case FreeRDP_OffscreenSupportLevel:
+                       return settings->OffscreenSupportLevel;
 
-               case FreeRDP_RedirectionAcceptedCertLength:
-                       return settings->RedirectionAcceptedCertLength;
+               case FreeRDP_OsMajorType:
+                       return settings->OsMajorType;
 
-               case FreeRDP_RedirectionPreferType:
-                       return settings->RedirectionPreferType;
+               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_SmartSizingWidth:
-                       return settings->SmartSizingWidth;
+               case FreeRDP_PerformanceFlags:
+                       return settings->PerformanceFlags;
 
-               case FreeRDP_SmartSizingHeight:
-                       return settings->SmartSizingHeight;
+               case FreeRDP_PointerCacheSize:
+                       return settings->PointerCacheSize;
 
-               case FreeRDP_GatewayUsageMethod:
-                       return settings->GatewayUsageMethod;
-
-               case FreeRDP_GatewayPort:
-                       return settings->GatewayPort;
-
-               case FreeRDP_GatewayCredentialsSource:
-                       return settings->GatewayCredentialsSource;
-
-               case FreeRDP_GatewayAcceptedCertLength:
-                       return settings->GatewayAcceptedCertLength;
+               case FreeRDP_PreconnectionId:
+                       return settings->PreconnectionId;
 
                case FreeRDP_ProxyType:
                        return settings->ProxyType;
 
-               case FreeRDP_RemoteApplicationExpandCmdLine:
-                       return settings->RemoteApplicationExpandCmdLine;
-
-               case FreeRDP_RemoteApplicationExpandWorkingDir:
-                       return settings->RemoteApplicationExpandWorkingDir;
-
-               case FreeRDP_RemoteAppNumIconCaches:
-                       return settings->RemoteAppNumIconCaches;
-
-               case FreeRDP_RemoteAppNumIconCacheEntries:
-                       return settings->RemoteAppNumIconCacheEntries;
-
-               case FreeRDP_RemoteWndSupportLevel:
-                       return settings->RemoteWndSupportLevel;
-
-               case FreeRDP_RemoteApplicationSupportLevel:
-                       return settings->RemoteApplicationSupportLevel;
-
-               case FreeRDP_RemoteApplicationSupportMask:
-                       return settings->RemoteApplicationSupportMask;
+               case FreeRDP_RdpVersion:
+                       return settings->RdpVersion;
 
                case FreeRDP_ReceivedCapabilitiesSize:
                        return settings->ReceivedCapabilitiesSize;
 
-               case FreeRDP_OsMajorType:
-                       return settings->OsMajorType;
-
-               case FreeRDP_OsMinorType:
-                       return settings->OsMinorType;
-
-               case FreeRDP_BitmapCacheVersion:
-                       return settings->BitmapCacheVersion;
-
-               case FreeRDP_BitmapCacheV2NumCells:
-                       return settings->BitmapCacheV2NumCells;
-
-               case FreeRDP_PointerCacheSize:
-                       return settings->PointerCacheSize;
-
-               case FreeRDP_KeyboardCodePage:
-                       return settings->KeyboardCodePage;
-
-               case FreeRDP_KeyboardLayout:
-                       return settings->KeyboardLayout;
-
-               case FreeRDP_KeyboardType:
-                       return settings->KeyboardType;
-
-               case FreeRDP_KeyboardSubType:
-                       return settings->KeyboardSubType;
+               case FreeRDP_RedirectedSessionId:
+                       return settings->RedirectedSessionId;
 
-               case FreeRDP_KeyboardFunctionKey:
-                       return settings->KeyboardFunctionKey;
+               case FreeRDP_RedirectionAcceptedCertLength:
+                       return settings->RedirectionAcceptedCertLength;
 
-               case FreeRDP_KeyboardHook:
-                       return settings->KeyboardHook;
+               case FreeRDP_RedirectionFlags:
+                       return settings->RedirectionFlags;
 
-               case FreeRDP_BrushSupportLevel:
-                       return settings->BrushSupportLevel;
+               case FreeRDP_RedirectionPasswordLength:
+                       return settings->RedirectionPasswordLength;
 
-               case FreeRDP_GlyphSupportLevel:
-                       return settings->GlyphSupportLevel;
+               case FreeRDP_RedirectionPreferType:
+                       return settings->RedirectionPreferType;
 
-               case FreeRDP_OffscreenSupportLevel:
-                       return settings->OffscreenSupportLevel;
+               case FreeRDP_RedirectionTsvUrlLength:
+                       return settings->RedirectionTsvUrlLength;
 
-               case FreeRDP_OffscreenCacheSize:
-                       return settings->OffscreenCacheSize;
+               case FreeRDP_RemoteAppNumIconCacheEntries:
+                       return settings->RemoteAppNumIconCacheEntries;
 
-               case FreeRDP_OffscreenCacheEntries:
-                       return settings->OffscreenCacheEntries;
+               case FreeRDP_RemoteAppNumIconCaches:
+                       return settings->RemoteAppNumIconCaches;
 
-               case FreeRDP_VirtualChannelCompressionFlags:
-                       return settings->VirtualChannelCompressionFlags;
+               case FreeRDP_RemoteApplicationExpandCmdLine:
+                       return settings->RemoteApplicationExpandCmdLine;
 
-               case FreeRDP_VirtualChannelChunkSize:
-                       return settings->VirtualChannelChunkSize;
+               case FreeRDP_RemoteApplicationExpandWorkingDir:
+                       return settings->RemoteApplicationExpandWorkingDir;
 
-               case FreeRDP_MultifragMaxRequestSize:
-                       return settings->MultifragMaxRequestSize;
+               case FreeRDP_RemoteApplicationSupportLevel:
+                       return settings->RemoteApplicationSupportLevel;
 
-               case FreeRDP_LargePointerFlag:
-                       return settings->LargePointerFlag;
+               case FreeRDP_RemoteApplicationSupportMask:
+                       return settings->RemoteApplicationSupportMask;
 
-               case FreeRDP_CompDeskSupportLevel:
-                       return settings->CompDeskSupportLevel;
+               case FreeRDP_RemoteFxCaptureFlags:
+                       return settings->RemoteFxCaptureFlags;
 
                case FreeRDP_RemoteFxCodecId:
                        return settings->RemoteFxCodecId;
@@ -1521,56 +1524,44 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id)
                case FreeRDP_RemoteFxCodecMode:
                        return settings->RemoteFxCodecMode;
 
-               case FreeRDP_RemoteFxCaptureFlags:
-                       return settings->RemoteFxCaptureFlags;
-
-               case FreeRDP_NSCodecId:
-                       return settings->NSCodecId;
-
-               case FreeRDP_FrameAcknowledge:
-                       return settings->FrameAcknowledge;
-
-               case FreeRDP_NSCodecColorLossLevel:
-                       return settings->NSCodecColorLossLevel;
-
-               case FreeRDP_JpegCodecId:
-                       return settings->JpegCodecId;
+               case FreeRDP_RemoteWndSupportLevel:
+                       return settings->RemoteWndSupportLevel;
 
-               case FreeRDP_JpegQuality:
-                       return settings->JpegQuality;
+               case FreeRDP_RequestedProtocols:
+                       return settings->RequestedProtocols;
 
-               case FreeRDP_GfxCapsFilter:
-                       return settings->GfxCapsFilter;
+               case FreeRDP_SelectedProtocol:
+                       return settings->SelectedProtocol;
 
-               case FreeRDP_BitmapCacheV3CodecId:
-                       return settings->BitmapCacheV3CodecId;
+               case FreeRDP_ServerCertificateLength:
+                       return settings->ServerCertificateLength;
 
-               case FreeRDP_DrawNineGridCacheSize:
-                       return settings->DrawNineGridCacheSize;
+               case FreeRDP_ServerPort:
+                       return settings->ServerPort;
 
-               case FreeRDP_DrawNineGridCacheEntries:
-                       return settings->DrawNineGridCacheEntries;
+               case FreeRDP_ServerRandomLength:
+                       return settings->ServerRandomLength;
 
-               case FreeRDP_DeviceCount:
-                       return settings->DeviceCount;
+               case FreeRDP_ShareId:
+                       return settings->ShareId;
 
-               case FreeRDP_DeviceArraySize:
-                       return settings->DeviceArraySize;
+               case FreeRDP_SmartSizingHeight:
+                       return settings->SmartSizingHeight;
 
-               case FreeRDP_StaticChannelCount:
-                       return settings->StaticChannelCount;
+               case FreeRDP_SmartSizingWidth:
+                       return settings->SmartSizingWidth;
 
                case FreeRDP_StaticChannelArraySize:
                        return settings->StaticChannelArraySize;
 
-               case FreeRDP_DynamicChannelCount:
-                       return settings->DynamicChannelCount;
+               case FreeRDP_StaticChannelCount:
+                       return settings->StaticChannelCount;
 
-               case FreeRDP_DynamicChannelArraySize:
-                       return settings->DynamicChannelArraySize;
+               case FreeRDP_TargetNetAddressCount:
+                       return settings->TargetNetAddressCount;
 
-               case FreeRDP_TcpKeepAliveRetries:
-                       return settings->TcpKeepAliveRetries;
+               case FreeRDP_TcpAckTimeout:
+                       return settings->TcpAckTimeout;
 
                case FreeRDP_TcpKeepAliveDelay:
                        return settings->TcpKeepAliveDelay;
@@ -1578,8 +1569,17 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id)
                case FreeRDP_TcpKeepAliveInterval:
                        return settings->TcpKeepAliveInterval;
 
-               case FreeRDP_TcpAckTimeout:
-                       return settings->TcpAckTimeout;
+               case FreeRDP_TcpKeepAliveRetries:
+                       return settings->TcpKeepAliveRetries;
+
+               case FreeRDP_TlsSecLevel:
+                       return settings->TlsSecLevel;
+
+               case FreeRDP_VirtualChannelChunkSize:
+                       return settings->VirtualChannelChunkSize;
+
+               case FreeRDP_VirtualChannelCompressionFlags:
+                       return settings->VirtualChannelCompressionFlags;
 
                default:
                        WLog_ERR(TAG, "[%s] Invalid key index %" PRIuz, __FUNCTION__, id);
@@ -1594,276 +1594,268 @@ BOOL freerdp_settings_set_uint32(rdpSettings* settings, size_t id, UINT32 val)
 
        switch (id)
        {
-               case FreeRDP_ShareId:
-                       settings->ShareId = val;
-                       break;
-
-               case FreeRDP_PduSource:
-                       settings->PduSource = val;
+               case FreeRDP_AcceptedCertLength:
+                       settings->AcceptedCertLength = val;
                        break;
 
-               case FreeRDP_ServerPort:
-                       settings->ServerPort = val;
+               case FreeRDP_AuthenticationLevel:
+                       settings->AuthenticationLevel = val;
                        break;
 
-               case FreeRDP_MaxTimeInCheckLoop:
-                       settings->MaxTimeInCheckLoop = val;
+               case FreeRDP_AutoReconnectMaxRetries:
+                       settings->AutoReconnectMaxRetries = val;
                        break;
 
-               case FreeRDP_AcceptedCertLength:
-                       settings->AcceptedCertLength = val;
+               case FreeRDP_BitmapCacheV2NumCells:
+                       settings->BitmapCacheV2NumCells = val;
                        break;
 
-               case FreeRDP_RdpVersion:
-                       settings->RdpVersion = val;
+               case FreeRDP_BitmapCacheV3CodecId:
+                       settings->BitmapCacheV3CodecId = val;
                        break;
 
-               case FreeRDP_DesktopWidth:
-                       settings->DesktopWidth = val;
+               case FreeRDP_BitmapCacheVersion:
+                       settings->BitmapCacheVersion = val;
                        break;
 
-               case FreeRDP_DesktopHeight:
-                       settings->DesktopHeight = val;
+               case FreeRDP_BrushSupportLevel:
+                       settings->BrushSupportLevel = val;
                        break;
 
-               case FreeRDP_ColorDepth:
-                       settings->ColorDepth = val;
+               case FreeRDP_ChannelCount:
+                       settings->ChannelCount = val;
                        break;
 
-               case FreeRDP_ConnectionType:
-                       settings->ConnectionType = val;
+               case FreeRDP_ChannelDefArraySize:
+                       settings->ChannelDefArraySize = val;
                        break;
 
                case FreeRDP_ClientBuild:
                        settings->ClientBuild = val;
                        break;
 
-               case FreeRDP_EarlyCapabilityFlags:
-                       settings->EarlyCapabilityFlags = val;
+               case FreeRDP_ClientRandomLength:
+                       settings->ClientRandomLength = val;
                        break;
 
-               case FreeRDP_DesktopPhysicalWidth:
-                       settings->DesktopPhysicalWidth = val;
+               case FreeRDP_ClusterInfoFlags:
+                       settings->ClusterInfoFlags = val;
                        break;
 
-               case FreeRDP_DesktopPhysicalHeight:
-                       settings->DesktopPhysicalHeight = val;
+               case FreeRDP_ColorDepth:
+                       settings->ColorDepth = val;
                        break;
 
-               case FreeRDP_DesktopScaleFactor:
-                       settings->DesktopScaleFactor = val;
+               case FreeRDP_CompDeskSupportLevel:
+                       settings->CompDeskSupportLevel = val;
                        break;
 
-               case FreeRDP_DeviceScaleFactor:
-                       settings->DeviceScaleFactor = val;
+               case FreeRDP_CompressionLevel:
+                       settings->CompressionLevel = val;
                        break;
 
-               case FreeRDP_EncryptionMethods:
-                       settings->EncryptionMethods = val;
+               case FreeRDP_ConnectionType:
+                       settings->ConnectionType = val;
                        break;
 
-               case FreeRDP_ExtEncryptionMethods:
-                       settings->ExtEncryptionMethods = val;
+               case FreeRDP_CookieMaxLength:
+                       settings->CookieMaxLength = val;
                        break;
 
-               case FreeRDP_EncryptionLevel:
-                       settings->EncryptionLevel = val;
+               case FreeRDP_DesktopHeight:
+                       settings->DesktopHeight = val;
                        break;
 
-               case FreeRDP_ServerRandomLength:
-                       settings->ServerRandomLength = val;
+               case FreeRDP_DesktopPhysicalHeight:
+                       settings->DesktopPhysicalHeight = val;
                        break;
 
-               case FreeRDP_ServerCertificateLength:
-                       settings->ServerCertificateLength = val;
-                       break;
-
-               case FreeRDP_ClientRandomLength:
-                       settings->ClientRandomLength = val;
+               case FreeRDP_DesktopPhysicalWidth:
+                       settings->DesktopPhysicalWidth = val;
                        break;
 
-               case FreeRDP_ChannelCount:
-                       settings->ChannelCount = val;
+               case FreeRDP_DesktopPosX:
+                       settings->DesktopPosX = val;
                        break;
 
-               case FreeRDP_ChannelDefArraySize:
-                       settings->ChannelDefArraySize = val;
+               case FreeRDP_DesktopPosY:
+                       settings->DesktopPosY = val;
                        break;
 
-               case FreeRDP_ClusterInfoFlags:
-                       settings->ClusterInfoFlags = val;
+               case FreeRDP_DesktopScaleFactor:
+                       settings->DesktopScaleFactor = val;
                        break;
 
-               case FreeRDP_RedirectedSessionId:
-                       settings->RedirectedSessionId = val;
+               case FreeRDP_DesktopWidth:
+                       settings->DesktopWidth = val;
                        break;
 
-               case FreeRDP_MonitorCount:
-                       settings->MonitorCount = val;
+               case FreeRDP_DeviceArraySize:
+                       settings->DeviceArraySize = val;
                        break;
 
-               case FreeRDP_MonitorDefArraySize:
-                       settings->MonitorDefArraySize = val;
+               case FreeRDP_DeviceCount:
+                       settings->DeviceCount = val;
                        break;
 
-               case FreeRDP_DesktopPosX:
-                       settings->DesktopPosX = val;
+               case FreeRDP_DeviceScaleFactor:
+                       settings->DeviceScaleFactor = val;
                        break;
 
-               case FreeRDP_DesktopPosY:
-                       settings->DesktopPosY = val;
+               case FreeRDP_DrawNineGridCacheEntries:
+                       settings->DrawNineGridCacheEntries = val;
                        break;
 
-               case FreeRDP_NumMonitorIds:
-                       settings->NumMonitorIds = val;
+               case FreeRDP_DrawNineGridCacheSize:
+                       settings->DrawNineGridCacheSize = val;
                        break;
 
-               case FreeRDP_MonitorLocalShiftX:
-                       settings->MonitorLocalShiftX = val;
+               case FreeRDP_DynamicChannelArraySize:
+                       settings->DynamicChannelArraySize = val;
                        break;
 
-               case FreeRDP_MonitorLocalShiftY:
-                       settings->MonitorLocalShiftY = val;
+               case FreeRDP_DynamicChannelCount:
+                       settings->DynamicChannelCount = val;
                        break;
 
-               case FreeRDP_MultitransportFlags:
-                       settings->MultitransportFlags = val;
+               case FreeRDP_EarlyCapabilityFlags:
+                       settings->EarlyCapabilityFlags = val;
                        break;
 
-               case FreeRDP_CompressionLevel:
-                       settings->CompressionLevel = val;
+               case FreeRDP_EncryptionLevel:
+                       settings->EncryptionLevel = val;
                        break;
 
-               case FreeRDP_AutoReconnectMaxRetries:
-                       settings->AutoReconnectMaxRetries = val;
+               case FreeRDP_EncryptionMethods:
+                       settings->EncryptionMethods = val;
                        break;
 
-               case FreeRDP_PerformanceFlags:
-                       settings->PerformanceFlags = val;
+               case FreeRDP_ExtEncryptionMethods:
+                       settings->ExtEncryptionMethods = val;
                        break;
 
-               case FreeRDP_RequestedProtocols:
-                       settings->RequestedProtocols = val;
+               case FreeRDP_FrameAcknowledge:
+                       settings->FrameAcknowledge = val;
                        break;
 
-               case FreeRDP_SelectedProtocol:
-                       settings->SelectedProtocol = val;
+               case FreeRDP_GatewayAcceptedCertLength:
+                       settings->GatewayAcceptedCertLength = val;
                        break;
 
-               case FreeRDP_NegotiationFlags:
-                       settings->NegotiationFlags = val;
+               case FreeRDP_GatewayCredentialsSource:
+                       settings->GatewayCredentialsSource = val;
                        break;
 
-               case FreeRDP_AuthenticationLevel:
-                       settings->AuthenticationLevel = val;
+               case FreeRDP_GatewayPort:
+                       settings->GatewayPort = val;
                        break;
 
-               case FreeRDP_TlsSecLevel:
-                       settings->TlsSecLevel = val;
+               case FreeRDP_GatewayUsageMethod:
+                       settings->GatewayUsageMethod = val;
                        break;
 
-               case FreeRDP_CookieMaxLength:
-                       settings->CookieMaxLength = val;
+               case FreeRDP_GfxCapsFilter:
+                       settings->GfxCapsFilter = val;
                        break;
 
-               case FreeRDP_PreconnectionId:
-                       settings->PreconnectionId = val;
+               case FreeRDP_GlyphSupportLevel:
+                       settings->GlyphSupportLevel = val;
                        break;
 
-               case FreeRDP_RedirectionFlags:
-                       settings->RedirectionFlags = val;
+               case FreeRDP_JpegCodecId:
+                       settings->JpegCodecId = val;
                        break;
 
-               case FreeRDP_LoadBalanceInfoLength:
-                       settings->LoadBalanceInfoLength = val;
+               case FreeRDP_JpegQuality:
+                       settings->JpegQuality = val;
                        break;
 
-               case FreeRDP_RedirectionPasswordLength:
-                       settings->RedirectionPasswordLength = val;
+               case FreeRDP_KeyboardCodePage:
+                       settings->KeyboardCodePage = val;
                        break;
 
-               case FreeRDP_RedirectionTsvUrlLength:
-                       settings->RedirectionTsvUrlLength = val;
+               case FreeRDP_KeyboardFunctionKey:
+                       settings->KeyboardFunctionKey = val;
                        break;
 
-               case FreeRDP_TargetNetAddressCount:
-                       settings->TargetNetAddressCount = val;
+               case FreeRDP_KeyboardHook:
+                       settings->KeyboardHook = val;
                        break;
 
-               case FreeRDP_RedirectionAcceptedCertLength:
-                       settings->RedirectionAcceptedCertLength = val;
+               case FreeRDP_KeyboardLayout:
+                       settings->KeyboardLayout = val;
                        break;
 
-               case FreeRDP_RedirectionPreferType:
-                       settings->RedirectionPreferType = val;
+               case FreeRDP_KeyboardSubType:
+                       settings->KeyboardSubType = val;
                        break;
 
-               case FreeRDP_Password51Length:
-                       settings->Password51Length = val;
+               case FreeRDP_KeyboardType:
+                       settings->KeyboardType = val;
                        break;
 
-               case FreeRDP_PercentScreen:
-                       settings->PercentScreen = val;
+               case FreeRDP_LargePointerFlag:
+                       settings->LargePointerFlag = val;
                        break;
 
-               case FreeRDP_SmartSizingWidth:
-                       settings->SmartSizingWidth = val;
+               case FreeRDP_LoadBalanceInfoLength:
+                       settings->LoadBalanceInfoLength = val;
                        break;
 
-               case FreeRDP_SmartSizingHeight:
-                       settings->SmartSizingHeight = val;
+               case FreeRDP_MaxTimeInCheckLoop:
+                       settings->MaxTimeInCheckLoop = val;
                        break;
 
-               case FreeRDP_GatewayUsageMethod:
-                       settings->GatewayUsageMethod = val;
+               case FreeRDP_MonitorCount:
+                       settings->MonitorCount = val;
                        break;
 
-               case FreeRDP_GatewayPort:
-                       settings->GatewayPort = val;
+               case FreeRDP_MonitorDefArraySize:
+                       settings->MonitorDefArraySize = val;
                        break;
 
-               case FreeRDP_GatewayCredentialsSource:
-                       settings->GatewayCredentialsSource = val;
+               case FreeRDP_MonitorLocalShiftX:
+                       settings->MonitorLocalShiftX = val;
                        break;
 
-               case FreeRDP_GatewayAcceptedCertLength:
-                       settings->GatewayAcceptedCertLength = val;
+               case FreeRDP_MonitorLocalShiftY:
+                       settings->MonitorLocalShiftY = val;
                        break;
 
-               case FreeRDP_ProxyType:
-                       settings->ProxyType = val;
+               case FreeRDP_MultifragMaxRequestSize:
+                       settings->MultifragMaxRequestSize = val;
                        break;
 
-               case FreeRDP_RemoteApplicationExpandCmdLine:
-                       settings->RemoteApplicationExpandCmdLine = val;
+               case FreeRDP_MultitransportFlags:
+                       settings->MultitransportFlags = val;
                        break;
 
-               case FreeRDP_RemoteApplicationExpandWorkingDir:
-                       settings->RemoteApplicationExpandWorkingDir = val;
+               case FreeRDP_NSCodecColorLossLevel:
+                       settings->NSCodecColorLossLevel = val;
                        break;
 
-               case FreeRDP_RemoteAppNumIconCaches:
-                       settings->RemoteAppNumIconCaches = val;
+               case FreeRDP_NSCodecId:
+                       settings->NSCodecId = val;
                        break;
 
-               case FreeRDP_RemoteAppNumIconCacheEntries:
-                       settings->RemoteAppNumIconCacheEntries = val;
+               case FreeRDP_NegotiationFlags:
+                       settings->NegotiationFlags = val;
                        break;
 
-               case FreeRDP_RemoteWndSupportLevel:
-                       settings->RemoteWndSupportLevel = val;
+               case FreeRDP_NumMonitorIds:
+                       settings->NumMonitorIds = val;
                        break;
 
-               case FreeRDP_RemoteApplicationSupportLevel:
-                       settings->RemoteApplicationSupportLevel = val;
+               case FreeRDP_OffscreenCacheEntries:
+                       settings->OffscreenCacheEntries = val;
                        break;
 
-               case FreeRDP_RemoteApplicationSupportMask:
-                       settings->RemoteApplicationSupportMask = val;
+               case FreeRDP_OffscreenCacheSize:
+                       settings->OffscreenCacheSize = val;
                        break;
 
-               case FreeRDP_ReceivedCapabilitiesSize:
-                       settings->ReceivedCapabilitiesSize = val;
+               case FreeRDP_OffscreenSupportLevel:
+                       settings->OffscreenSupportLevel = val;
                        break;
 
                case FreeRDP_OsMajorType:
@@ -1874,156 +1866,152 @@ BOOL freerdp_settings_set_uint32(rdpSettings* settings, size_t id, UINT32 val)
                        settings->OsMinorType = val;
                        break;
 
-               case FreeRDP_BitmapCacheVersion:
-                       settings->BitmapCacheVersion = val;
+               case FreeRDP_Password51Length:
+                       settings->Password51Length = val;
                        break;
 
-               case FreeRDP_BitmapCacheV2NumCells:
-                       settings->BitmapCacheV2NumCells = val;
+               case FreeRDP_PduSource:
+                       settings->PduSource = val;
                        break;
 
-               case FreeRDP_PointerCacheSize:
-                       settings->PointerCacheSize = val;
+               case FreeRDP_PercentScreen:
+                       settings->PercentScreen = val;
                        break;
 
-               case FreeRDP_KeyboardCodePage:
-                       settings->KeyboardCodePage = val;
+               case FreeRDP_PerformanceFlags:
+                       settings->PerformanceFlags = val;
                        break;
 
-               case FreeRDP_KeyboardLayout:
-                       settings->KeyboardLayout = val;
+               case FreeRDP_PointerCacheSize:
+                       settings->PointerCacheSize = val;
                        break;
 
-               case FreeRDP_KeyboardType:
-                       settings->KeyboardType = val;
+               case FreeRDP_PreconnectionId:
+                       settings->PreconnectionId = val;
                        break;
 
-               case FreeRDP_KeyboardSubType:
-                       settings->KeyboardSubType = val;
+               case FreeRDP_ProxyType:
+                       settings->ProxyType = val;
                        break;
 
-               case FreeRDP_KeyboardFunctionKey:
-                       settings->KeyboardFunctionKey = val;
+               case FreeRDP_RdpVersion:
+                       settings->RdpVersion = val;
                        break;
 
-               case FreeRDP_KeyboardHook:
-                       settings->KeyboardHook = val;
+               case FreeRDP_ReceivedCapabilitiesSize:
+                       settings->ReceivedCapabilitiesSize = val;
                        break;
 
-               case FreeRDP_BrushSupportLevel:
-                       settings->BrushSupportLevel = val;
+               case FreeRDP_RedirectedSessionId:
+                       settings->RedirectedSessionId = val;
                        break;
 
-               case FreeRDP_GlyphSupportLevel:
-                       settings->GlyphSupportLevel = val;
+               case FreeRDP_RedirectionAcceptedCertLength:
+                       settings->RedirectionAcceptedCertLength = val;
                        break;
 
-               case FreeRDP_OffscreenSupportLevel:
-                       settings->OffscreenSupportLevel = val;
+               case FreeRDP_RedirectionFlags:
+                       settings->RedirectionFlags = val;
                        break;
 
-               case FreeRDP_OffscreenCacheSize:
-                       settings->OffscreenCacheSize = val;
+               case FreeRDP_RedirectionPasswordLength:
+                       settings->RedirectionPasswordLength = val;
                        break;
 
-               case FreeRDP_OffscreenCacheEntries:
-                       settings->OffscreenCacheEntries = val;
+               case FreeRDP_RedirectionPreferType:
+                       settings->RedirectionPreferType = val;
                        break;
 
-               case FreeRDP_VirtualChannelCompressionFlags:
-                       settings->VirtualChannelCompressionFlags = val;
+               case FreeRDP_RedirectionTsvUrlLength:
+                       settings->RedirectionTsvUrlLength = val;
                        break;
 
-               case FreeRDP_VirtualChannelChunkSize:
-                       settings->VirtualChannelChunkSize = val;
+               case FreeRDP_RemoteAppNumIconCacheEntries:
+                       settings->RemoteAppNumIconCacheEntries = val;
                        break;
 
-               case FreeRDP_MultifragMaxRequestSize:
-                       settings->MultifragMaxRequestSize = val;
+               case FreeRDP_RemoteAppNumIconCaches:
+                       settings->RemoteAppNumIconCaches = val;
                        break;
 
-               case FreeRDP_LargePointerFlag:
-                       settings->LargePointerFlag = val;
+               case FreeRDP_RemoteApplicationExpandCmdLine:
+                       settings->RemoteApplicationExpandCmdLine = val;
                        break;
 
-               case FreeRDP_CompDeskSupportLevel:
-                       settings->CompDeskSupportLevel = val;
+               case FreeRDP_RemoteApplicationExpandWorkingDir:
+                       settings->RemoteApplicationExpandWorkingDir = val;
                        break;
 
-               case FreeRDP_RemoteFxCodecId:
-                       settings->RemoteFxCodecId = val;
+               case FreeRDP_RemoteApplicationSupportLevel:
+                       settings->RemoteApplicationSupportLevel = val;
                        break;
 
-               case FreeRDP_RemoteFxCodecMode:
-                       settings->RemoteFxCodecMode = val;
+               case FreeRDP_RemoteApplicationSupportMask:
+                       settings->RemoteApplicationSupportMask = val;
                        break;
 
                case FreeRDP_RemoteFxCaptureFlags:
                        settings->RemoteFxCaptureFlags = val;
                        break;
 
-               case FreeRDP_NSCodecId:
-                       settings->NSCodecId = val;
-                       break;
-
-               case FreeRDP_FrameAcknowledge:
-                       settings->FrameAcknowledge = val;
+               case FreeRDP_RemoteFxCodecId:
+                       settings->RemoteFxCodecId = val;
                        break;
 
-               case FreeRDP_NSCodecColorLossLevel:
-                       settings->NSCodecColorLossLevel = val;
+               case FreeRDP_RemoteFxCodecMode:
+                       settings->RemoteFxCodecMode = val;
                        break;
 
-               case FreeRDP_JpegCodecId:
-                       settings->JpegCodecId = val;
+               case FreeRDP_RemoteWndSupportLevel:
+                       settings->RemoteWndSupportLevel = val;
                        break;
 
-               case FreeRDP_JpegQuality:
-                       settings->JpegQuality = val;
+               case FreeRDP_RequestedProtocols:
+                       settings->RequestedProtocols = val;
                        break;
 
-               case FreeRDP_GfxCapsFilter:
-                       settings->GfxCapsFilter = val;
+               case FreeRDP_SelectedProtocol:
+                       settings->SelectedProtocol = val;
                        break;
 
-               case FreeRDP_BitmapCacheV3CodecId:
-                       settings->BitmapCacheV3CodecId = val;
+               case FreeRDP_ServerCertificateLength:
+                       settings->ServerCertificateLength = val;
                        break;
 
-               case FreeRDP_DrawNineGridCacheSize:
-                       settings->DrawNineGridCacheSize = val;
+               case FreeRDP_ServerPort:
+                       settings->ServerPort = val;
                        break;
 
-               case FreeRDP_DrawNineGridCacheEntries:
-                       settings->DrawNineGridCacheEntries = val;
+               case FreeRDP_ServerRandomLength:
+                       settings->ServerRandomLength = val;
                        break;
 
-               case FreeRDP_DeviceCount:
-                       settings->DeviceCount = val;
+               case FreeRDP_ShareId:
+                       settings->ShareId = val;
                        break;
 
-               case FreeRDP_DeviceArraySize:
-                       settings->DeviceArraySize = val;
+               case FreeRDP_SmartSizingHeight:
+                       settings->SmartSizingHeight = val;
                        break;
 
-               case FreeRDP_StaticChannelCount:
-                       settings->StaticChannelCount = val;
+               case FreeRDP_SmartSizingWidth:
+                       settings->SmartSizingWidth = val;
                        break;
 
                case FreeRDP_StaticChannelArraySize:
                        settings->StaticChannelArraySize = val;
                        break;
 
-               case FreeRDP_DynamicChannelCount:
-                       settings->DynamicChannelCount = val;
+               case FreeRDP_StaticChannelCount:
+                       settings->StaticChannelCount = val;
                        break;
 
-               case FreeRDP_DynamicChannelArraySize:
-                       settings->DynamicChannelArraySize = val;
+               case FreeRDP_TargetNetAddressCount:
+                       settings->TargetNetAddressCount = val;
                        break;
 
-               case FreeRDP_TcpKeepAliveRetries:
-                       settings->TcpKeepAliveRetries = val;
+               case FreeRDP_TcpAckTimeout:
+                       settings->TcpAckTimeout = val;
                        break;
 
                case FreeRDP_TcpKeepAliveDelay:
@@ -2034,8 +2022,20 @@ BOOL freerdp_settings_set_uint32(rdpSettings* settings, size_t id, UINT32 val)
                        settings->TcpKeepAliveInterval = val;
                        break;
 
-               case FreeRDP_TcpAckTimeout:
-                       settings->TcpAckTimeout = val;
+               case FreeRDP_TcpKeepAliveRetries:
+                       settings->TcpKeepAliveRetries = val;
+                       break;
+
+               case FreeRDP_TlsSecLevel:
+                       settings->TlsSecLevel = val;
+                       break;
+
+               case FreeRDP_VirtualChannelChunkSize:
+                       settings->VirtualChannelChunkSize = val;
+                       break;
+
+               case FreeRDP_VirtualChannelCompressionFlags:
+                       settings->VirtualChannelCompressionFlags = val;
                        break;
 
                default:
@@ -2154,35 +2154,32 @@ const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id)
 
        switch (id)
        {
-               case FreeRDP_ServerHostname:
-                       return settings->ServerHostname;
-
-               case FreeRDP_Username:
-                       return settings->Username;
+               case FreeRDP_AcceptedCert:
+                       return settings->AcceptedCert;
 
-               case FreeRDP_Password:
-                       return settings->Password;
+               case FreeRDP_AllowedTlsCiphers:
+                       return settings->AllowedTlsCiphers;
 
-               case FreeRDP_Domain:
-                       return settings->Domain;
+               case FreeRDP_AlternateShell:
+                       return settings->AlternateShell;
 
-               case FreeRDP_PasswordHash:
-                       return settings->PasswordHash;
+               case FreeRDP_AssistanceFile:
+                       return settings->AssistanceFile;
 
-               case FreeRDP_AcceptedCert:
-                       return settings->AcceptedCert;
+               case FreeRDP_AuthenticationServiceClass:
+                       return settings->AuthenticationServiceClass;
 
-               case FreeRDP_ClientHostname:
-                       return settings->ClientHostname;
+               case FreeRDP_CertificateAcceptedFingerprints:
+                       return settings->CertificateAcceptedFingerprints;
 
-               case FreeRDP_ClientProductId:
-                       return settings->ClientProductId;
+               case FreeRDP_CertificateContent:
+                       return settings->CertificateContent;
 
-               case FreeRDP_AlternateShell:
-                       return settings->AlternateShell;
+               case FreeRDP_CertificateFile:
+                       return settings->CertificateFile;
 
-               case FreeRDP_ShellWorkingDirectory:
-                       return settings->ShellWorkingDirectory;
+               case FreeRDP_CertificateName:
+                       return settings->CertificateName;
 
                case FreeRDP_ClientAddress:
                        return settings->ClientAddress;
@@ -2190,50 +2187,59 @@ const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id)
                case FreeRDP_ClientDir:
                        return settings->ClientDir;
 
-               case FreeRDP_DynamicDSTTimeZoneKeyName:
-                       return settings->DynamicDSTTimeZoneKeyName;
+               case FreeRDP_ClientHostname:
+                       return settings->ClientHostname;
 
-               case FreeRDP_RemoteAssistanceSessionId:
-                       return settings->RemoteAssistanceSessionId;
+               case FreeRDP_ClientProductId:
+                       return settings->ClientProductId;
 
-               case FreeRDP_RemoteAssistancePassStub:
-                       return settings->RemoteAssistancePassStub;
+               case FreeRDP_ComputerName:
+                       return settings->ComputerName;
 
-               case FreeRDP_RemoteAssistancePassword:
-                       return settings->RemoteAssistancePassword;
+               case FreeRDP_ConfigPath:
+                       return settings->ConfigPath;
 
-               case FreeRDP_RemoteAssistanceRCTicket:
-                       return settings->RemoteAssistanceRCTicket;
+               case FreeRDP_ConnectionFile:
+                       return settings->ConnectionFile;
 
-               case FreeRDP_AuthenticationServiceClass:
-                       return settings->AuthenticationServiceClass;
+               case FreeRDP_CurrentPath:
+                       return settings->CurrentPath;
 
-               case FreeRDP_AllowedTlsCiphers:
-                       return settings->AllowedTlsCiphers;
+               case FreeRDP_Domain:
+                       return settings->Domain;
 
-               case FreeRDP_NtlmSamFile:
-                       return settings->NtlmSamFile;
+               case FreeRDP_DrivesToRedirect:
+                       return settings->DrivesToRedirect;
 
-               case FreeRDP_PreconnectionBlob:
-                       return settings->PreconnectionBlob;
+               case FreeRDP_DumpRemoteFxFile:
+                       return settings->DumpRemoteFxFile;
 
-               case FreeRDP_TargetNetAddress:
-                       return settings->TargetNetAddress;
+               case FreeRDP_DynamicDSTTimeZoneKeyName:
+                       return settings->DynamicDSTTimeZoneKeyName;
 
-               case FreeRDP_RedirectionUsername:
-                       return settings->RedirectionUsername;
+               case FreeRDP_GatewayAcceptedCert:
+                       return settings->GatewayAcceptedCert;
 
-               case FreeRDP_RedirectionDomain:
-                       return settings->RedirectionDomain;
+               case FreeRDP_GatewayAccessToken:
+                       return settings->GatewayAccessToken;
 
-               case FreeRDP_RedirectionTargetFQDN:
-                       return settings->RedirectionTargetFQDN;
+               case FreeRDP_GatewayDomain:
+                       return settings->GatewayDomain;
 
-               case FreeRDP_RedirectionTargetNetBiosName:
-                       return settings->RedirectionTargetNetBiosName;
+               case FreeRDP_GatewayHostname:
+                       return settings->GatewayHostname;
 
-               case FreeRDP_RedirectionAcceptedCert:
-                       return settings->RedirectionAcceptedCert;
+               case FreeRDP_GatewayPassword:
+                       return settings->GatewayPassword;
+
+               case FreeRDP_GatewayUsername:
+                       return settings->GatewayUsername;
+
+               case FreeRDP_HomePath:
+                       return settings->HomePath;
+
+               case FreeRDP_ImeFileName:
+                       return settings->ImeFileName;
 
                case FreeRDP_KerberosKdc:
                        return settings->KerberosKdc;
@@ -2241,116 +2247,110 @@ const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id)
                case FreeRDP_KerberosRealm:
                        return settings->KerberosRealm;
 
-               case FreeRDP_CertificateName:
-                       return settings->CertificateName;
+               case FreeRDP_NtlmSamFile:
+                       return settings->NtlmSamFile;
 
-               case FreeRDP_CertificateFile:
-                       return settings->CertificateFile;
+               case FreeRDP_Password:
+                       return settings->Password;
 
-               case FreeRDP_PrivateKeyFile:
-                       return settings->PrivateKeyFile;
+               case FreeRDP_PasswordHash:
+                       return settings->PasswordHash;
 
-               case FreeRDP_RdpKeyFile:
-                       return settings->RdpKeyFile;
+               case FreeRDP_PlayRemoteFxFile:
+                       return settings->PlayRemoteFxFile;
 
-               case FreeRDP_CertificateContent:
-                       return settings->CertificateContent;
+               case FreeRDP_PreconnectionBlob:
+                       return settings->PreconnectionBlob;
 
                case FreeRDP_PrivateKeyContent:
                        return settings->PrivateKeyContent;
 
-               case FreeRDP_RdpKeyContent:
-                       return settings->RdpKeyContent;
+               case FreeRDP_PrivateKeyFile:
+                       return settings->PrivateKeyFile;
 
-               case FreeRDP_CertificateAcceptedFingerprints:
-                       return settings->CertificateAcceptedFingerprints;
+               case FreeRDP_ProxyHostname:
+                       return settings->ProxyHostname;
 
-               case FreeRDP_WindowTitle:
-                       return settings->WindowTitle;
+               case FreeRDP_ProxyPassword:
+                       return settings->ProxyPassword;
 
-               case FreeRDP_WmClass:
-                       return settings->WmClass;
+               case FreeRDP_ProxyUsername:
+                       return settings->ProxyUsername;
 
-               case FreeRDP_ComputerName:
-                       return settings->ComputerName;
+               case FreeRDP_RDP2TCPArgs:
+                       return settings->RDP2TCPArgs;
 
-               case FreeRDP_ConnectionFile:
-                       return settings->ConnectionFile;
+               case FreeRDP_RdpKeyContent:
+                       return settings->RdpKeyContent;
 
-               case FreeRDP_AssistanceFile:
-                       return settings->AssistanceFile;
+               case FreeRDP_RdpKeyFile:
+                       return settings->RdpKeyFile;
 
-               case FreeRDP_HomePath:
-                       return settings->HomePath;
+               case FreeRDP_RedirectionAcceptedCert:
+                       return settings->RedirectionAcceptedCert;
 
-               case FreeRDP_ConfigPath:
-                       return settings->ConfigPath;
-
-               case FreeRDP_CurrentPath:
-                       return settings->CurrentPath;
-
-               case FreeRDP_DumpRemoteFxFile:
-                       return settings->DumpRemoteFxFile;
-
-               case FreeRDP_PlayRemoteFxFile:
-                       return settings->PlayRemoteFxFile;
-
-               case FreeRDP_GatewayHostname:
-                       return settings->GatewayHostname;
-
-               case FreeRDP_GatewayUsername:
-                       return settings->GatewayUsername;
+               case FreeRDP_RedirectionDomain:
+                       return settings->RedirectionDomain;
 
-               case FreeRDP_GatewayPassword:
-                       return settings->GatewayPassword;
+               case FreeRDP_RedirectionTargetFQDN:
+                       return settings->RedirectionTargetFQDN;
 
-               case FreeRDP_GatewayDomain:
-                       return settings->GatewayDomain;
+               case FreeRDP_RedirectionTargetNetBiosName:
+                       return settings->RedirectionTargetNetBiosName;
 
-               case FreeRDP_GatewayAccessToken:
-                       return settings->GatewayAccessToken;
+               case FreeRDP_RedirectionUsername:
+                       return settings->RedirectionUsername;
 
-               case FreeRDP_GatewayAcceptedCert:
-                       return settings->GatewayAcceptedCert;
+               case FreeRDP_RemoteApplicationCmdLine:
+                       return settings->RemoteApplicationCmdLine;
 
-               case FreeRDP_ProxyHostname:
-                       return settings->ProxyHostname;
+               case FreeRDP_RemoteApplicationFile:
+                       return settings->RemoteApplicationFile;
 
-               case FreeRDP_ProxyUsername:
-                       return settings->ProxyUsername;
+               case FreeRDP_RemoteApplicationGuid:
+                       return settings->RemoteApplicationGuid;
 
-               case FreeRDP_ProxyPassword:
-                       return settings->ProxyPassword;
+               case FreeRDP_RemoteApplicationIcon:
+                       return settings->RemoteApplicationIcon;
 
                case FreeRDP_RemoteApplicationName:
                        return settings->RemoteApplicationName;
 
-               case FreeRDP_RemoteApplicationIcon:
-                       return settings->RemoteApplicationIcon;
-
                case FreeRDP_RemoteApplicationProgram:
                        return settings->RemoteApplicationProgram;
 
-               case FreeRDP_RemoteApplicationFile:
-                       return settings->RemoteApplicationFile;
+               case FreeRDP_RemoteApplicationWorkingDir:
+                       return settings->RemoteApplicationWorkingDir;
 
-               case FreeRDP_RemoteApplicationGuid:
-                       return settings->RemoteApplicationGuid;
+               case FreeRDP_RemoteAssistancePassStub:
+                       return settings->RemoteAssistancePassStub;
 
-               case FreeRDP_RemoteApplicationCmdLine:
-                       return settings->RemoteApplicationCmdLine;
+               case FreeRDP_RemoteAssistancePassword:
+                       return settings->RemoteAssistancePassword;
 
-               case FreeRDP_RemoteApplicationWorkingDir:
-                       return settings->RemoteApplicationWorkingDir;
+               case FreeRDP_RemoteAssistanceRCTicket:
+                       return settings->RemoteAssistanceRCTicket;
 
-               case FreeRDP_ImeFileName:
-                       return settings->ImeFileName;
+               case FreeRDP_RemoteAssistanceSessionId:
+                       return settings->RemoteAssistanceSessionId;
 
-               case FreeRDP_DrivesToRedirect:
-                       return settings->DrivesToRedirect;
+               case FreeRDP_ServerHostname:
+                       return settings->ServerHostname;
 
-               case FreeRDP_RDP2TCPArgs:
-                       return settings->RDP2TCPArgs;
+               case FreeRDP_ShellWorkingDirectory:
+                       return settings->ShellWorkingDirectory;
+
+               case FreeRDP_TargetNetAddress:
+                       return settings->TargetNetAddress;
+
+               case FreeRDP_Username:
+                       return settings->Username;
+
+               case FreeRDP_WindowTitle:
+                       return settings->WindowTitle;
+
+               case FreeRDP_WmClass:
+                       return settings->WmClass;
 
                default:
                        WLog_ERR(TAG, "[%s] Invalid key index %" PRIuz, __FUNCTION__, id);
@@ -2365,300 +2365,255 @@ BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* v
 
        switch (id)
        {
-               case FreeRDP_ServerHostname:
-                       free(settings->ServerHostname);
-                       settings->ServerHostname = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ServerHostname != NULL);
-
-               case FreeRDP_Username:
-                       free(settings->Username);
-                       settings->Username = (val ? _strdup(val) : NULL);
-                       return (!val || settings->Username != NULL);
-
-               case FreeRDP_Password:
-                       free(settings->Password);
-                       settings->Password = (val ? _strdup(val) : NULL);
-                       return (!val || settings->Password != NULL);
-
-               case FreeRDP_Domain:
-                       free(settings->Domain);
-                       settings->Domain = (val ? _strdup(val) : NULL);
-                       return (!val || settings->Domain != NULL);
-
-               case FreeRDP_PasswordHash:
-                       free(settings->PasswordHash);
-                       settings->PasswordHash = (val ? _strdup(val) : NULL);
-                       return (!val || settings->PasswordHash != NULL);
-
                case FreeRDP_AcceptedCert:
                        free(settings->AcceptedCert);
                        settings->AcceptedCert = (val ? _strdup(val) : NULL);
                        return (!val || settings->AcceptedCert != NULL);
 
-               case FreeRDP_ClientHostname:
-                       free(settings->ClientHostname);
-                       settings->ClientHostname = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ClientHostname != NULL);
-
-               case FreeRDP_ClientProductId:
-                       free(settings->ClientProductId);
-                       settings->ClientProductId = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ClientProductId != NULL);
+               case FreeRDP_AllowedTlsCiphers:
+                       free(settings->AllowedTlsCiphers);
+                       settings->AllowedTlsCiphers = (val ? _strdup(val) : NULL);
+                       return (!val || settings->AllowedTlsCiphers != NULL);
 
                case FreeRDP_AlternateShell:
                        free(settings->AlternateShell);
                        settings->AlternateShell = (val ? _strdup(val) : NULL);
                        return (!val || settings->AlternateShell != NULL);
 
-               case FreeRDP_ShellWorkingDirectory:
-                       free(settings->ShellWorkingDirectory);
-                       settings->ShellWorkingDirectory = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ShellWorkingDirectory != NULL);
-
-               case FreeRDP_ClientAddress:
-                       free(settings->ClientAddress);
-                       settings->ClientAddress = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ClientAddress != NULL);
-
-               case FreeRDP_ClientDir:
-                       free(settings->ClientDir);
-                       settings->ClientDir = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ClientDir != NULL);
-
-               case FreeRDP_DynamicDSTTimeZoneKeyName:
-                       free(settings->DynamicDSTTimeZoneKeyName);
-                       settings->DynamicDSTTimeZoneKeyName = (val ? _strdup(val) : NULL);
-                       return (!val || settings->DynamicDSTTimeZoneKeyName != NULL);
-
-               case FreeRDP_RemoteAssistanceSessionId:
-                       free(settings->RemoteAssistanceSessionId);
-                       settings->RemoteAssistanceSessionId = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteAssistanceSessionId != NULL);
-
-               case FreeRDP_RemoteAssistancePassStub:
-                       free(settings->RemoteAssistancePassStub);
-                       settings->RemoteAssistancePassStub = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteAssistancePassStub != NULL);
-
-               case FreeRDP_RemoteAssistancePassword:
-                       free(settings->RemoteAssistancePassword);
-                       settings->RemoteAssistancePassword = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteAssistancePassword != NULL);
-
-               case FreeRDP_RemoteAssistanceRCTicket:
-                       free(settings->RemoteAssistanceRCTicket);
-                       settings->RemoteAssistanceRCTicket = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteAssistanceRCTicket != NULL);
+               case FreeRDP_AssistanceFile:
+                       free(settings->AssistanceFile);
+                       settings->AssistanceFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->AssistanceFile != NULL);
 
                case FreeRDP_AuthenticationServiceClass:
                        free(settings->AuthenticationServiceClass);
                        settings->AuthenticationServiceClass = (val ? _strdup(val) : NULL);
                        return (!val || settings->AuthenticationServiceClass != NULL);
 
-               case FreeRDP_AllowedTlsCiphers:
-                       free(settings->AllowedTlsCiphers);
-                       settings->AllowedTlsCiphers = (val ? _strdup(val) : NULL);
-                       return (!val || settings->AllowedTlsCiphers != NULL);
-
-               case FreeRDP_NtlmSamFile:
-                       free(settings->NtlmSamFile);
-                       settings->NtlmSamFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->NtlmSamFile != NULL);
-
-               case FreeRDP_PreconnectionBlob:
-                       free(settings->PreconnectionBlob);
-                       settings->PreconnectionBlob = (val ? _strdup(val) : NULL);
-                       return (!val || settings->PreconnectionBlob != NULL);
-
-               case FreeRDP_TargetNetAddress:
-                       free(settings->TargetNetAddress);
-                       settings->TargetNetAddress = (val ? _strdup(val) : NULL);
-                       return (!val || settings->TargetNetAddress != NULL);
-
-               case FreeRDP_RedirectionUsername:
-                       free(settings->RedirectionUsername);
-                       settings->RedirectionUsername = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RedirectionUsername != NULL);
-
-               case FreeRDP_RedirectionDomain:
-                       free(settings->RedirectionDomain);
-                       settings->RedirectionDomain = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RedirectionDomain != NULL);
-
-               case FreeRDP_RedirectionTargetFQDN:
-                       free(settings->RedirectionTargetFQDN);
-                       settings->RedirectionTargetFQDN = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RedirectionTargetFQDN != NULL);
-
-               case FreeRDP_RedirectionTargetNetBiosName:
-                       free(settings->RedirectionTargetNetBiosName);
-                       settings->RedirectionTargetNetBiosName = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RedirectionTargetNetBiosName != NULL);
-
-               case FreeRDP_RedirectionAcceptedCert:
-                       free(settings->RedirectionAcceptedCert);
-                       settings->RedirectionAcceptedCert = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RedirectionAcceptedCert != NULL);
-
-               case FreeRDP_KerberosKdc:
-                       free(settings->KerberosKdc);
-                       settings->KerberosKdc = (val ? _strdup(val) : NULL);
-                       return (!val || settings->KerberosKdc != NULL);
-
-               case FreeRDP_KerberosRealm:
-                       free(settings->KerberosRealm);
-                       settings->KerberosRealm = (val ? _strdup(val) : NULL);
-                       return (!val || settings->KerberosRealm != NULL);
+               case FreeRDP_CertificateAcceptedFingerprints:
+                       free(settings->CertificateAcceptedFingerprints);
+                       settings->CertificateAcceptedFingerprints = (val ? _strdup(val) : NULL);
+                       return (!val || settings->CertificateAcceptedFingerprints != NULL);
 
-               case FreeRDP_CertificateName:
-                       free(settings->CertificateName);
-                       settings->CertificateName = (val ? _strdup(val) : NULL);
-                       return (!val || settings->CertificateName != NULL);
+               case FreeRDP_CertificateContent:
+                       free(settings->CertificateContent);
+                       settings->CertificateContent = (val ? _strdup(val) : NULL);
+                       return (!val || settings->CertificateContent != NULL);
 
                case FreeRDP_CertificateFile:
                        free(settings->CertificateFile);
                        settings->CertificateFile = (val ? _strdup(val) : NULL);
                        return (!val || settings->CertificateFile != NULL);
 
-               case FreeRDP_PrivateKeyFile:
-                       free(settings->PrivateKeyFile);
-                       settings->PrivateKeyFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->PrivateKeyFile != NULL);
-
-               case FreeRDP_RdpKeyFile:
-                       free(settings->RdpKeyFile);
-                       settings->RdpKeyFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RdpKeyFile != NULL);
-
-               case FreeRDP_CertificateContent:
-                       free(settings->CertificateContent);
-                       settings->CertificateContent = (val ? _strdup(val) : NULL);
-                       return (!val || settings->CertificateContent != NULL);
-
-               case FreeRDP_PrivateKeyContent:
-                       free(settings->PrivateKeyContent);
-                       settings->PrivateKeyContent = (val ? _strdup(val) : NULL);
-                       return (!val || settings->PrivateKeyContent != NULL);
+               case FreeRDP_CertificateName:
+                       free(settings->CertificateName);
+                       settings->CertificateName = (val ? _strdup(val) : NULL);
+                       return (!val || settings->CertificateName != NULL);
 
-               case FreeRDP_RdpKeyContent:
-                       free(settings->RdpKeyContent);
-                       settings->RdpKeyContent = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RdpKeyContent != NULL);
+               case FreeRDP_ClientAddress:
+                       free(settings->ClientAddress);
+                       settings->ClientAddress = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ClientAddress != NULL);
 
-               case FreeRDP_CertificateAcceptedFingerprints:
-                       free(settings->CertificateAcceptedFingerprints);
-                       settings->CertificateAcceptedFingerprints = (val ? _strdup(val) : NULL);
-                       return (!val || settings->CertificateAcceptedFingerprints != NULL);
+               case FreeRDP_ClientDir:
+                       free(settings->ClientDir);
+                       settings->ClientDir = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ClientDir != NULL);
 
-               case FreeRDP_WindowTitle:
-                       free(settings->WindowTitle);
-                       settings->WindowTitle = (val ? _strdup(val) : NULL);
-                       return (!val || settings->WindowTitle != NULL);
+               case FreeRDP_ClientHostname:
+                       free(settings->ClientHostname);
+                       settings->ClientHostname = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ClientHostname != NULL);
 
-               case FreeRDP_WmClass:
-                       free(settings->WmClass);
-                       settings->WmClass = (val ? _strdup(val) : NULL);
-                       return (!val || settings->WmClass != NULL);
+               case FreeRDP_ClientProductId:
+                       free(settings->ClientProductId);
+                       settings->ClientProductId = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ClientProductId != NULL);
 
                case FreeRDP_ComputerName:
                        free(settings->ComputerName);
                        settings->ComputerName = (val ? _strdup(val) : NULL);
                        return (!val || settings->ComputerName != NULL);
 
-               case FreeRDP_ConnectionFile:
-                       free(settings->ConnectionFile);
-                       settings->ConnectionFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ConnectionFile != NULL);
-
-               case FreeRDP_AssistanceFile:
-                       free(settings->AssistanceFile);
-                       settings->AssistanceFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->AssistanceFile != NULL);
-
-               case FreeRDP_HomePath:
-                       free(settings->HomePath);
-                       settings->HomePath = (val ? _strdup(val) : NULL);
-                       return (!val || settings->HomePath != NULL);
-
                case FreeRDP_ConfigPath:
                        free(settings->ConfigPath);
                        settings->ConfigPath = (val ? _strdup(val) : NULL);
                        return (!val || settings->ConfigPath != NULL);
 
+               case FreeRDP_ConnectionFile:
+                       free(settings->ConnectionFile);
+                       settings->ConnectionFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ConnectionFile != NULL);
+
                case FreeRDP_CurrentPath:
                        free(settings->CurrentPath);
                        settings->CurrentPath = (val ? _strdup(val) : NULL);
                        return (!val || settings->CurrentPath != NULL);
 
+               case FreeRDP_Domain:
+                       free(settings->Domain);
+                       settings->Domain = (val ? _strdup(val) : NULL);
+                       return (!val || settings->Domain != NULL);
+
+               case FreeRDP_DrivesToRedirect:
+                       free(settings->DrivesToRedirect);
+                       settings->DrivesToRedirect = (val ? _strdup(val) : NULL);
+                       return (!val || settings->DrivesToRedirect != NULL);
+
                case FreeRDP_DumpRemoteFxFile:
                        free(settings->DumpRemoteFxFile);
                        settings->DumpRemoteFxFile = (val ? _strdup(val) : NULL);
                        return (!val || settings->DumpRemoteFxFile != NULL);
 
-               case FreeRDP_PlayRemoteFxFile:
-                       free(settings->PlayRemoteFxFile);
-                       settings->PlayRemoteFxFile = (val ? _strdup(val) : NULL);
-                       return (!val || settings->PlayRemoteFxFile != NULL);
+               case FreeRDP_DynamicDSTTimeZoneKeyName:
+                       free(settings->DynamicDSTTimeZoneKeyName);
+                       settings->DynamicDSTTimeZoneKeyName = (val ? _strdup(val) : NULL);
+                       return (!val || settings->DynamicDSTTimeZoneKeyName != NULL);
+
+               case FreeRDP_GatewayAcceptedCert:
+                       free(settings->GatewayAcceptedCert);
+                       settings->GatewayAcceptedCert = (val ? _strdup(val) : NULL);
+                       return (!val || settings->GatewayAcceptedCert != NULL);
+
+               case FreeRDP_GatewayAccessToken:
+                       free(settings->GatewayAccessToken);
+                       settings->GatewayAccessToken = (val ? _strdup(val) : NULL);
+                       return (!val || settings->GatewayAccessToken != NULL);
+
+               case FreeRDP_GatewayDomain:
+                       free(settings->GatewayDomain);
+                       settings->GatewayDomain = (val ? _strdup(val) : NULL);
+                       return (!val || settings->GatewayDomain != NULL);
 
                case FreeRDP_GatewayHostname:
                        free(settings->GatewayHostname);
                        settings->GatewayHostname = (val ? _strdup(val) : NULL);
                        return (!val || settings->GatewayHostname != NULL);
 
+               case FreeRDP_GatewayPassword:
+                       free(settings->GatewayPassword);
+                       settings->GatewayPassword = (val ? _strdup(val) : NULL);
+                       return (!val || settings->GatewayPassword != NULL);
+
                case FreeRDP_GatewayUsername:
                        free(settings->GatewayUsername);
                        settings->GatewayUsername = (val ? _strdup(val) : NULL);
                        return (!val || settings->GatewayUsername != NULL);
 
-               case FreeRDP_GatewayPassword:
-                       free(settings->GatewayPassword);
-                       settings->GatewayPassword = (val ? _strdup(val) : NULL);
-                       return (!val || settings->GatewayPassword != NULL);
+               case FreeRDP_HomePath:
+                       free(settings->HomePath);
+                       settings->HomePath = (val ? _strdup(val) : NULL);
+                       return (!val || settings->HomePath != NULL);
+
+               case FreeRDP_ImeFileName:
+                       free(settings->ImeFileName);
+                       settings->ImeFileName = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ImeFileName != NULL);
+
+               case FreeRDP_KerberosKdc:
+                       free(settings->KerberosKdc);
+                       settings->KerberosKdc = (val ? _strdup(val) : NULL);
+                       return (!val || settings->KerberosKdc != NULL);
+
+               case FreeRDP_KerberosRealm:
+                       free(settings->KerberosRealm);
+                       settings->KerberosRealm = (val ? _strdup(val) : NULL);
+                       return (!val || settings->KerberosRealm != NULL);
+
+               case FreeRDP_NtlmSamFile:
+                       free(settings->NtlmSamFile);
+                       settings->NtlmSamFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->NtlmSamFile != NULL);
+
+               case FreeRDP_Password:
+                       free(settings->Password);
+                       settings->Password = (val ? _strdup(val) : NULL);
+                       return (!val || settings->Password != NULL);
+
+               case FreeRDP_PasswordHash:
+                       free(settings->PasswordHash);
+                       settings->PasswordHash = (val ? _strdup(val) : NULL);
+                       return (!val || settings->PasswordHash != NULL);
+
+               case FreeRDP_PlayRemoteFxFile:
+                       free(settings->PlayRemoteFxFile);
+                       settings->PlayRemoteFxFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->PlayRemoteFxFile != NULL);
 
-               case FreeRDP_GatewayDomain:
-                       free(settings->GatewayDomain);
-                       settings->GatewayDomain = (val ? _strdup(val) : NULL);
-                       return (!val || settings->GatewayDomain != NULL);
+               case FreeRDP_PreconnectionBlob:
+                       free(settings->PreconnectionBlob);
+                       settings->PreconnectionBlob = (val ? _strdup(val) : NULL);
+                       return (!val || settings->PreconnectionBlob != NULL);
 
-               case FreeRDP_GatewayAccessToken:
-                       free(settings->GatewayAccessToken);
-                       settings->GatewayAccessToken = (val ? _strdup(val) : NULL);
-                       return (!val || settings->GatewayAccessToken != NULL);
+               case FreeRDP_PrivateKeyContent:
+                       free(settings->PrivateKeyContent);
+                       settings->PrivateKeyContent = (val ? _strdup(val) : NULL);
+                       return (!val || settings->PrivateKeyContent != NULL);
 
-               case FreeRDP_GatewayAcceptedCert:
-                       free(settings->GatewayAcceptedCert);
-                       settings->GatewayAcceptedCert = (val ? _strdup(val) : NULL);
-                       return (!val || settings->GatewayAcceptedCert != NULL);
+               case FreeRDP_PrivateKeyFile:
+                       free(settings->PrivateKeyFile);
+                       settings->PrivateKeyFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->PrivateKeyFile != NULL);
 
                case FreeRDP_ProxyHostname:
                        free(settings->ProxyHostname);
                        settings->ProxyHostname = (val ? _strdup(val) : NULL);
                        return (!val || settings->ProxyHostname != NULL);
 
+               case FreeRDP_ProxyPassword:
+                       free(settings->ProxyPassword);
+                       settings->ProxyPassword = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ProxyPassword != NULL);
+
                case FreeRDP_ProxyUsername:
                        free(settings->ProxyUsername);
                        settings->ProxyUsername = (val ? _strdup(val) : NULL);
                        return (!val || settings->ProxyUsername != NULL);
 
-               case FreeRDP_ProxyPassword:
-                       free(settings->ProxyPassword);
-                       settings->ProxyPassword = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ProxyPassword != NULL);
+               case FreeRDP_RDP2TCPArgs:
+                       free(settings->RDP2TCPArgs);
+                       settings->RDP2TCPArgs = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RDP2TCPArgs != NULL);
 
-               case FreeRDP_RemoteApplicationName:
-                       free(settings->RemoteApplicationName);
-                       settings->RemoteApplicationName = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteApplicationName != NULL);
+               case FreeRDP_RdpKeyContent:
+                       free(settings->RdpKeyContent);
+                       settings->RdpKeyContent = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RdpKeyContent != NULL);
 
-               case FreeRDP_RemoteApplicationIcon:
-                       free(settings->RemoteApplicationIcon);
-                       settings->RemoteApplicationIcon = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteApplicationIcon != NULL);
+               case FreeRDP_RdpKeyFile:
+                       free(settings->RdpKeyFile);
+                       settings->RdpKeyFile = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RdpKeyFile != NULL);
 
-               case FreeRDP_RemoteApplicationProgram:
-                       free(settings->RemoteApplicationProgram);
-                       settings->RemoteApplicationProgram = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteApplicationProgram != NULL);
+               case FreeRDP_RedirectionAcceptedCert:
+                       free(settings->RedirectionAcceptedCert);
+                       settings->RedirectionAcceptedCert = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RedirectionAcceptedCert != NULL);
+
+               case FreeRDP_RedirectionDomain:
+                       free(settings->RedirectionDomain);
+                       settings->RedirectionDomain = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RedirectionDomain != NULL);
+
+               case FreeRDP_RedirectionTargetFQDN:
+                       free(settings->RedirectionTargetFQDN);
+                       settings->RedirectionTargetFQDN = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RedirectionTargetFQDN != NULL);
+
+               case FreeRDP_RedirectionTargetNetBiosName:
+                       free(settings->RedirectionTargetNetBiosName);
+                       settings->RedirectionTargetNetBiosName = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RedirectionTargetNetBiosName != NULL);
+
+               case FreeRDP_RedirectionUsername:
+                       free(settings->RedirectionUsername);
+                       settings->RedirectionUsername = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RedirectionUsername != NULL);
+
+               case FreeRDP_RemoteApplicationCmdLine:
+                       free(settings->RemoteApplicationCmdLine);
+                       settings->RemoteApplicationCmdLine = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteApplicationCmdLine != NULL);
 
                case FreeRDP_RemoteApplicationFile:
                        free(settings->RemoteApplicationFile);
@@ -2670,30 +2625,75 @@ BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* v
                        settings->RemoteApplicationGuid = (val ? _strdup(val) : NULL);
                        return (!val || settings->RemoteApplicationGuid != NULL);
 
-               case FreeRDP_RemoteApplicationCmdLine:
-                       free(settings->RemoteApplicationCmdLine);
-                       settings->RemoteApplicationCmdLine = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RemoteApplicationCmdLine != NULL);
+               case FreeRDP_RemoteApplicationIcon:
+                       free(settings->RemoteApplicationIcon);
+                       settings->RemoteApplicationIcon = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteApplicationIcon != NULL);
+
+               case FreeRDP_RemoteApplicationName:
+                       free(settings->RemoteApplicationName);
+                       settings->RemoteApplicationName = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteApplicationName != NULL);
+
+               case FreeRDP_RemoteApplicationProgram:
+                       free(settings->RemoteApplicationProgram);
+                       settings->RemoteApplicationProgram = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteApplicationProgram != NULL);
 
                case FreeRDP_RemoteApplicationWorkingDir:
                        free(settings->RemoteApplicationWorkingDir);
                        settings->RemoteApplicationWorkingDir = (val ? _strdup(val) : NULL);
                        return (!val || settings->RemoteApplicationWorkingDir != NULL);
 
-               case FreeRDP_ImeFileName:
-                       free(settings->ImeFileName);
-                       settings->ImeFileName = (val ? _strdup(val) : NULL);
-                       return (!val || settings->ImeFileName != NULL);
+               case FreeRDP_RemoteAssistancePassStub:
+                       free(settings->RemoteAssistancePassStub);
+                       settings->RemoteAssistancePassStub = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteAssistancePassStub != NULL);
 
-               case FreeRDP_DrivesToRedirect:
-                       free(settings->DrivesToRedirect);
-                       settings->DrivesToRedirect = (val ? _strdup(val) : NULL);
-                       return (!val || settings->DrivesToRedirect != NULL);
+               case FreeRDP_RemoteAssistancePassword:
+                       free(settings->RemoteAssistancePassword);
+                       settings->RemoteAssistancePassword = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteAssistancePassword != NULL);
 
-               case FreeRDP_RDP2TCPArgs:
-                       free(settings->RDP2TCPArgs);
-                       settings->RDP2TCPArgs = (val ? _strdup(val) : NULL);
-                       return (!val || settings->RDP2TCPArgs != NULL);
+               case FreeRDP_RemoteAssistanceRCTicket:
+                       free(settings->RemoteAssistanceRCTicket);
+                       settings->RemoteAssistanceRCTicket = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteAssistanceRCTicket != NULL);
+
+               case FreeRDP_RemoteAssistanceSessionId:
+                       free(settings->RemoteAssistanceSessionId);
+                       settings->RemoteAssistanceSessionId = (val ? _strdup(val) : NULL);
+                       return (!val || settings->RemoteAssistanceSessionId != NULL);
+
+               case FreeRDP_ServerHostname:
+                       free(settings->ServerHostname);
+                       settings->ServerHostname = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ServerHostname != NULL);
+
+               case FreeRDP_ShellWorkingDirectory:
+                       free(settings->ShellWorkingDirectory);
+                       settings->ShellWorkingDirectory = (val ? _strdup(val) : NULL);
+                       return (!val || settings->ShellWorkingDirectory != NULL);
+
+               case FreeRDP_TargetNetAddress:
+                       free(settings->TargetNetAddress);
+                       settings->TargetNetAddress = (val ? _strdup(val) : NULL);
+                       return (!val || settings->TargetNetAddress != NULL);
+
+               case FreeRDP_Username:
+                       free(settings->Username);
+                       settings->Username = (val ? _strdup(val) : NULL);
+                       return (!val || settings->Username != NULL);
+
+               case FreeRDP_WindowTitle:
+                       free(settings->WindowTitle);
+                       settings->WindowTitle = (val ? _strdup(val) : NULL);
+                       return (!val || settings->WindowTitle != NULL);
+
+               case FreeRDP_WmClass:
+                       free(settings->WmClass);
+                       settings->WmClass = (val ? _strdup(val) : NULL);
+                       return (!val || settings->WmClass != NULL);
 
                default:
                        WLog_ERR(TAG, "[%s] Invalid key index %" PRIuz, __FUNCTION__, id);
@@ -2709,68 +2709,56 @@ const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id)
 
        switch (id)
        {
-               case FreeRDP_instance:
-                       return settings->instance;
-
-               case FreeRDP_RdpServerCertificate:
-                       return settings->RdpServerCertificate;
-
-               case FreeRDP_ServerAutoReconnectCookie:
-                       return settings->ServerAutoReconnectCookie;
-
                case FreeRDP_BitmapCacheV2CellInfo:
                        return settings->BitmapCacheV2CellInfo;
 
-               case FreeRDP_RdpServerRsaKey:
-                       return settings->RdpServerRsaKey;
-
-               case FreeRDP_MonitorIds:
-                       return settings->MonitorIds;
-
-               case FreeRDP_TargetNetPorts:
-                       return settings->TargetNetPorts;
-
-               case FreeRDP_MonitorDefArray:
-                       return settings->MonitorDefArray;
-
                case FreeRDP_ChannelDefArray:
                        return settings->ChannelDefArray;
 
                case FreeRDP_ClientAutoReconnectCookie:
                        return settings->ClientAutoReconnectCookie;
 
-               case FreeRDP_TargetNetAddresses:
-                       return settings->TargetNetAddresses;
+               case FreeRDP_ClientRandom:
+                       return settings->ClientRandom;
 
-               case FreeRDP_StaticChannelArray:
-                       return settings->StaticChannelArray;
+               case FreeRDP_ClientTimeZone:
+                       return settings->ClientTimeZone;
+
+               case FreeRDP_DeviceArray:
+                       return settings->DeviceArray;
 
                case FreeRDP_DynamicChannelArray:
                        return settings->DynamicChannelArray;
 
-               case FreeRDP_DeviceArray:
-                       return settings->DeviceArray;
+               case FreeRDP_FragCache:
+                       return settings->FragCache;
 
                case FreeRDP_GlyphCache:
                        return settings->GlyphCache;
 
-               case FreeRDP_FragCache:
-                       return settings->FragCache;
+               case FreeRDP_LoadBalanceInfo:
+                       return settings->LoadBalanceInfo;
 
-               case FreeRDP_ClientTimeZone:
-                       return settings->ClientTimeZone;
+               case FreeRDP_MonitorDefArray:
+                       return settings->MonitorDefArray;
 
-               case FreeRDP_ServerRandom:
-                       return settings->ServerRandom;
+               case FreeRDP_MonitorIds:
+                       return settings->MonitorIds;
 
-               case FreeRDP_ServerCertificate:
-                       return settings->ServerCertificate;
+               case FreeRDP_OrderSupport:
+                       return settings->OrderSupport;
 
-               case FreeRDP_ClientRandom:
-                       return settings->ClientRandom;
+               case FreeRDP_Password51:
+                       return settings->Password51;
 
-               case FreeRDP_LoadBalanceInfo:
-                       return settings->LoadBalanceInfo;
+               case FreeRDP_RdpServerCertificate:
+                       return settings->RdpServerCertificate;
+
+               case FreeRDP_RdpServerRsaKey:
+                       return settings->RdpServerRsaKey;
+
+               case FreeRDP_ReceivedCapabilities:
+                       return settings->ReceivedCapabilities;
 
                case FreeRDP_RedirectionPassword:
                        return settings->RedirectionPassword;
@@ -2778,14 +2766,26 @@ const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id)
                case FreeRDP_RedirectionTsvUrl:
                        return settings->RedirectionTsvUrl;
 
-               case FreeRDP_Password51:
-                       return settings->Password51;
+               case FreeRDP_ServerAutoReconnectCookie:
+                       return settings->ServerAutoReconnectCookie;
 
-               case FreeRDP_ReceivedCapabilities:
-                       return settings->ReceivedCapabilities;
+               case FreeRDP_ServerCertificate:
+                       return settings->ServerCertificate;
 
-               case FreeRDP_OrderSupport:
-                       return settings->OrderSupport;
+               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, "[%s] Invalid key index %" PRIuz, __FUNCTION__, id);

diff --git a/libfreerdp/common/settings_str.c b/libfreerdp/common/settings_str.c
new file mode 100644 (file)
index 0000000..8ba0b38
--- /dev/null
+++ b/libfreerdp/common/settings_str.c
@@ -0,0 +1,434 @@
+/* Generated by  */
+
+#include <freerdp/settings.h>
+#include <freerdp/log.h>
+
+#define TAG FREERDP_TAG("common.settings")
+
+struct settings_str_entry
+{
+       size_t id;
+       size_t type;
+       const char* str;
+};
+static const struct settings_str_entry settings_map[] = {
+       { FreeRDP_AllowCacheWaitingList, 0, "FreeRDP_AllowCacheWaitingList" },
+       { FreeRDP_AllowDesktopComposition, 0, "FreeRDP_AllowDesktopComposition" },
+       { FreeRDP_AllowFontSmoothing, 0, "FreeRDP_AllowFontSmoothing" },
+       { FreeRDP_AllowUnanouncedOrdersFromServer, 0, "FreeRDP_AllowUnanouncedOrdersFromServer" },
+       { FreeRDP_AltSecFrameMarkerSupport, 0, "FreeRDP_AltSecFrameMarkerSupport" },
+       { FreeRDP_AsyncChannels, 0, "FreeRDP_AsyncChannels" },
+       { FreeRDP_AsyncInput, 0, "FreeRDP_AsyncInput" },
+       { FreeRDP_AsyncUpdate, 0, "FreeRDP_AsyncUpdate" },
+       { FreeRDP_AudioCapture, 0, "FreeRDP_AudioCapture" },
+       { FreeRDP_AudioPlayback, 0, "FreeRDP_AudioPlayback" },
+       { FreeRDP_Authentication, 0, "FreeRDP_Authentication" },
+       { FreeRDP_AuthenticationOnly, 0, "FreeRDP_AuthenticationOnly" },
+       { FreeRDP_AutoAcceptCertificate, 0, "FreeRDP_AutoAcceptCertificate" },
+       { FreeRDP_AutoDenyCertificate, 0, "FreeRDP_AutoDenyCertificate" },
+       { FreeRDP_AutoLogonEnabled, 0, "FreeRDP_AutoLogonEnabled" },
+       { FreeRDP_AutoReconnectionEnabled, 0, "FreeRDP_AutoReconnectionEnabled" },
+       { FreeRDP_BitmapCacheEnabled, 0, "FreeRDP_BitmapCacheEnabled" },
+       { FreeRDP_BitmapCachePersistEnabled, 0, "FreeRDP_BitmapCachePersistEnabled" },
+       { FreeRDP_BitmapCacheV3Enabled, 0, "FreeRDP_BitmapCacheV3Enabled" },
+       { FreeRDP_BitmapCompressionDisabled, 0, "FreeRDP_BitmapCompressionDisabled" },
+       { FreeRDP_ColorPointerFlag, 0, "FreeRDP_ColorPointerFlag" },
+       { FreeRDP_CompressionEnabled, 0, "FreeRDP_CompressionEnabled" },
+       { FreeRDP_ConsoleSession, 0, "FreeRDP_ConsoleSession" },
+       { FreeRDP_CredentialsFromStdin, 0, "FreeRDP_CredentialsFromStdin" },
+       { FreeRDP_Decorations, 0, "FreeRDP_Decorations" },
+       { FreeRDP_DesktopResize, 0, "FreeRDP_DesktopResize" },
+       { FreeRDP_DeviceRedirection, 0, "FreeRDP_DeviceRedirection" },
+       { FreeRDP_DisableCredentialsDelegation, 0, "FreeRDP_DisableCredentialsDelegation" },
+       { FreeRDP_DisableCtrlAltDel, 0, "FreeRDP_DisableCtrlAltDel" },
+       { FreeRDP_DisableCursorBlinking, 0, "FreeRDP_DisableCursorBlinking" },
+       { FreeRDP_DisableCursorShadow, 0, "FreeRDP_DisableCursorShadow" },
+       { FreeRDP_DisableFullWindowDrag, 0, "FreeRDP_DisableFullWindowDrag" },
+       { FreeRDP_DisableMenuAnims, 0, "FreeRDP_DisableMenuAnims" },
+       { FreeRDP_DisableRemoteAppCapsCheck, 0, "FreeRDP_DisableRemoteAppCapsCheck" },
+       { FreeRDP_DisableThemes, 0, "FreeRDP_DisableThemes" },
+       { FreeRDP_DisableWallpaper, 0, "FreeRDP_DisableWallpaper" },
+       { FreeRDP_DrawAllowColorSubsampling, 0, "FreeRDP_DrawAllowColorSubsampling" },
+       { FreeRDP_DrawAllowDynamicColorFidelity, 0, "FreeRDP_DrawAllowDynamicColorFidelity" },
+       { FreeRDP_DrawAllowSkipAlpha, 0, "FreeRDP_DrawAllowSkipAlpha" },
+       { FreeRDP_DrawGdiPlusCacheEnabled, 0, "FreeRDP_DrawGdiPlusCacheEnabled" },
+       { FreeRDP_DrawGdiPlusEnabled, 0, "FreeRDP_DrawGdiPlusEnabled" },
+       { FreeRDP_DrawNineGridEnabled, 0, "FreeRDP_DrawNineGridEnabled" },
+       { FreeRDP_DumpRemoteFx, 0, "FreeRDP_DumpRemoteFx" },
+       { FreeRDP_DynamicDaylightTimeDisabled, 0, "FreeRDP_DynamicDaylightTimeDisabled" },
+       { FreeRDP_DynamicResolutionUpdate, 0, "FreeRDP_DynamicResolutionUpdate" },
+       { FreeRDP_EmbeddedWindow, 0, "FreeRDP_EmbeddedWindow" },
+       { FreeRDP_EnableWindowsKey, 0, "FreeRDP_EnableWindowsKey" },
+       { FreeRDP_EncomspVirtualChannel, 0, "FreeRDP_EncomspVirtualChannel" },
+       { FreeRDP_ExtSecurity, 0, "FreeRDP_ExtSecurity" },
+       { FreeRDP_ExternalCertificateManagement, 0, "FreeRDP_ExternalCertificateManagement" },
+       { FreeRDP_FIPSMode, 0, "FreeRDP_FIPSMode" },
+       { FreeRDP_FastPathInput, 0, "FreeRDP_FastPathInput" },
+       { FreeRDP_FastPathOutput, 0, "FreeRDP_FastPathOutput" },
+       { FreeRDP_ForceEncryptedCsPdu, 0, "FreeRDP_ForceEncryptedCsPdu" },
+       { FreeRDP_ForceMultimon, 0, "FreeRDP_ForceMultimon" },
+       { FreeRDP_FrameMarkerCommandEnabled, 0, "FreeRDP_FrameMarkerCommandEnabled" },
+       { FreeRDP_Fullscreen, 0, "FreeRDP_Fullscreen" },
+       { FreeRDP_GatewayBypassLocal, 0, "FreeRDP_GatewayBypassLocal" },
+       { FreeRDP_GatewayEnabled, 0, "FreeRDP_GatewayEnabled" },
+       { FreeRDP_GatewayHttpTransport, 0, "FreeRDP_GatewayHttpTransport" },
+       { FreeRDP_GatewayRpcTransport, 0, "FreeRDP_GatewayRpcTransport" },
+       { FreeRDP_GatewayUdpTransport, 0, "FreeRDP_GatewayUdpTransport" },
+       { FreeRDP_GatewayUseSameCredentials, 0, "FreeRDP_GatewayUseSameCredentials" },
+       { FreeRDP_GfxAVC444, 0, "FreeRDP_GfxAVC444" },
+       { FreeRDP_GfxAVC444v2, 0, "FreeRDP_GfxAVC444v2" },
+       { FreeRDP_GfxH264, 0, "FreeRDP_GfxH264" },
+       { FreeRDP_GfxProgressive, 0, "FreeRDP_GfxProgressive" },
+       { FreeRDP_GfxProgressiveV2, 0, "FreeRDP_GfxProgressiveV2" },
+       { FreeRDP_GfxSendQoeAck, 0, "FreeRDP_GfxSendQoeAck" },
+       { FreeRDP_GfxSmallCache, 0, "FreeRDP_GfxSmallCache" },
+       { FreeRDP_GfxThinClient, 0, "FreeRDP_GfxThinClient" },
+       { FreeRDP_GrabKeyboard, 0, "FreeRDP_GrabKeyboard" },
+       { FreeRDP_HasExtendedMouseEvent, 0, "FreeRDP_HasExtendedMouseEvent" },
+       { FreeRDP_HasHorizontalWheel, 0, "FreeRDP_HasHorizontalWheel" },
+       { FreeRDP_HasMonitorAttributes, 0, "FreeRDP_HasMonitorAttributes" },
+       { FreeRDP_HiDefRemoteApp, 0, "FreeRDP_HiDefRemoteApp" },
+       { FreeRDP_IPv6Enabled, 0, "FreeRDP_IPv6Enabled" },
+       { FreeRDP_IgnoreCertificate, 0, "FreeRDP_IgnoreCertificate" },
+       { FreeRDP_JpegCodec, 0, "FreeRDP_JpegCodec" },
+       { FreeRDP_ListMonitors, 0, "FreeRDP_ListMonitors" },
+       { FreeRDP_LocalConnection, 0, "FreeRDP_LocalConnection" },
+       { FreeRDP_LogonErrors, 0, "FreeRDP_LogonErrors" },
+       { FreeRDP_LogonNotify, 0, "FreeRDP_LogonNotify" },
+       { FreeRDP_LongCredentialsSupported, 0, "FreeRDP_LongCredentialsSupported" },
+       { FreeRDP_LyncRdpMode, 0, "FreeRDP_LyncRdpMode" },
+       { FreeRDP_MaximizeShell, 0, "FreeRDP_MaximizeShell" },
+       { FreeRDP_MouseAttached, 0, "FreeRDP_MouseAttached" },
+       { FreeRDP_MouseHasWheel, 0, "FreeRDP_MouseHasWheel" },
+       { FreeRDP_MouseMotion, 0, "FreeRDP_MouseMotion" },
+       { FreeRDP_MstscCookieMode, 0, "FreeRDP_MstscCookieMode" },
+       { FreeRDP_MultiTouchGestures, 0, "FreeRDP_MultiTouchGestures" },
+       { FreeRDP_MultiTouchInput, 0, "FreeRDP_MultiTouchInput" },
+       { FreeRDP_NSCodec, 0, "FreeRDP_NSCodec" },
+       { FreeRDP_NSCodecAllowDynamicColorFidelity, 0, "FreeRDP_NSCodecAllowDynamicColorFidelity" },
+       { FreeRDP_NSCodecAllowSubsampling, 0, "FreeRDP_NSCodecAllowSubsampling" },
+       { FreeRDP_NegotiateSecurityLayer, 0, "FreeRDP_NegotiateSecurityLayer" },
+       { FreeRDP_NetworkAutoDetect, 0, "FreeRDP_NetworkAutoDetect" },
+       { FreeRDP_NlaSecurity, 0, "FreeRDP_NlaSecurity" },
+       { FreeRDP_NoBitmapCompressionHeader, 0, "FreeRDP_NoBitmapCompressionHeader" },
+       { FreeRDP_OldLicenseBehaviour, 0, "FreeRDP_OldLicenseBehaviour" },
+       { FreeRDP_PasswordIsSmartcardPin, 0, "FreeRDP_PasswordIsSmartcardPin" },
+       { FreeRDP_PercentScreenUseHeight, 0, "FreeRDP_PercentScreenUseHeight" },
+       { FreeRDP_PercentScreenUseWidth, 0, "FreeRDP_PercentScreenUseWidth" },
+       { FreeRDP_PlayRemoteFx, 0, "FreeRDP_PlayRemoteFx" },
+       { FreeRDP_PreferIPv6OverIPv4, 0, "FreeRDP_PreferIPv6OverIPv4" },
+       { FreeRDP_PrintReconnectCookie, 0, "FreeRDP_PrintReconnectCookie" },
+       { FreeRDP_PromptForCredentials, 0, "FreeRDP_PromptForCredentials" },
+       { FreeRDP_RdpSecurity, 0, "FreeRDP_RdpSecurity" },
+       { FreeRDP_RedirectClipboard, 0, "FreeRDP_RedirectClipboard" },
+       { FreeRDP_RedirectDrives, 0, "FreeRDP_RedirectDrives" },
+       { FreeRDP_RedirectHomeDrive, 0, "FreeRDP_RedirectHomeDrive" },
+       { FreeRDP_RedirectParallelPorts, 0, "FreeRDP_RedirectParallelPorts" },
+       { FreeRDP_RedirectPrinters, 0, "FreeRDP_RedirectPrinters" },
+       { FreeRDP_RedirectSerialPorts, 0, "FreeRDP_RedirectSerialPorts" },
+       { FreeRDP_RedirectSmartCards, 0, "FreeRDP_RedirectSmartCards" },
+       { FreeRDP_RefreshRect, 0, "FreeRDP_RefreshRect" },
+       { FreeRDP_RemdeskVirtualChannel, 0, "FreeRDP_RemdeskVirtualChannel" },
+       { FreeRDP_RemoteAppLanguageBarSupported, 0, "FreeRDP_RemoteAppLanguageBarSupported" },
+       { FreeRDP_RemoteApplicationMode, 0, "FreeRDP_RemoteApplicationMode" },
+       { FreeRDP_RemoteAssistanceMode, 0, "FreeRDP_RemoteAssistanceMode" },
+       { FreeRDP_RemoteAssistanceRequestControl, 0, "FreeRDP_RemoteAssistanceRequestControl" },
+       { FreeRDP_RemoteConsoleAudio, 0, "FreeRDP_RemoteConsoleAudio" },
+       { FreeRDP_RemoteFxCodec, 0, "FreeRDP_RemoteFxCodec" },
+       { FreeRDP_RemoteFxImageCodec, 0, "FreeRDP_RemoteFxImageCodec" },
+       { FreeRDP_RemoteFxOnly, 0, "FreeRDP_RemoteFxOnly" },
+       { FreeRDP_RestrictedAdminModeRequired, 0, "FreeRDP_RestrictedAdminModeRequired" },
+       { FreeRDP_SaltedChecksum, 0, "FreeRDP_SaltedChecksum" },
+       { FreeRDP_SendPreconnectionPdu, 0, "FreeRDP_SendPreconnectionPdu" },
+       { FreeRDP_ServerMode, 0, "FreeRDP_ServerMode" },
+       { FreeRDP_SmartSizing, 0, "FreeRDP_SmartSizing" },
+       { FreeRDP_SmartcardLogon, 0, "FreeRDP_SmartcardLogon" },
+       { FreeRDP_SoftwareGdi, 0, "FreeRDP_SoftwareGdi" },
+       { FreeRDP_SoundBeepsEnabled, 0, "FreeRDP_SoundBeepsEnabled" },
+       { FreeRDP_SpanMonitors, 0, "FreeRDP_SpanMonitors" },
+       { FreeRDP_SupportAsymetricKeys, 0, "FreeRDP_SupportAsymetricKeys" },
+       { FreeRDP_SupportDisplayControl, 0, "FreeRDP_SupportDisplayControl" },
+       { FreeRDP_SupportDynamicChannels, 0, "FreeRDP_SupportDynamicChannels" },
+       { FreeRDP_SupportDynamicTimeZone, 0, "FreeRDP_SupportDynamicTimeZone" },
+       { FreeRDP_SupportEchoChannel, 0, "FreeRDP_SupportEchoChannel" },
+       { FreeRDP_SupportErrorInfoPdu, 0, "FreeRDP_SupportErrorInfoPdu" },
+       { FreeRDP_SupportGeometryTracking, 0, "FreeRDP_SupportGeometryTracking" },
+       { FreeRDP_SupportGraphicsPipeline, 0, "FreeRDP_SupportGraphicsPipeline" },
+       { FreeRDP_SupportHeartbeatPdu, 0, "FreeRDP_SupportHeartbeatPdu" },
+       { FreeRDP_SupportMonitorLayoutPdu, 0, "FreeRDP_SupportMonitorLayoutPdu" },
+       { FreeRDP_SupportMultitransport, 0, "FreeRDP_SupportMultitransport" },
+       { FreeRDP_SupportSSHAgentChannel, 0, "FreeRDP_SupportSSHAgentChannel" },
+       { FreeRDP_SupportStatusInfoPdu, 0, "FreeRDP_SupportStatusInfoPdu" },
+       { FreeRDP_SupportVideoOptimized, 0, "FreeRDP_SupportVideoOptimized" },
+       { FreeRDP_SuppressOutput, 0, "FreeRDP_SuppressOutput" },
+       { FreeRDP_SurfaceCommandsEnabled, 0, "FreeRDP_SurfaceCommandsEnabled" },
+       { FreeRDP_SurfaceFrameMarkerEnabled, 0, "FreeRDP_SurfaceFrameMarkerEnabled" },
+       { FreeRDP_TcpKeepAlive, 0, "FreeRDP_TcpKeepAlive" },
+       { FreeRDP_TlsSecurity, 0, "FreeRDP_TlsSecurity" },
+       { FreeRDP_ToggleFullscreen, 0, "FreeRDP_ToggleFullscreen" },
+       { FreeRDP_UnicodeInput, 0, "FreeRDP_UnicodeInput" },
+       { FreeRDP_UnmapButtons, 0, "FreeRDP_UnmapButtons" },
+       { FreeRDP_UseMultimon, 0, "FreeRDP_UseMultimon" },
+       { FreeRDP_UseRdpSecurityLayer, 0, "FreeRDP_UseRdpSecurityLayer" },
+       { FreeRDP_UsingSavedCredentials, 0, "FreeRDP_UsingSavedCredentials" },
+       { FreeRDP_VideoDisable, 0, "FreeRDP_VideoDisable" },
+       { FreeRDP_VmConnectMode, 0, "FreeRDP_VmConnectMode" },
+       { FreeRDP_WaitForOutputBufferFlush, 0, "FreeRDP_WaitForOutputBufferFlush" },
+       { FreeRDP_Workarea, 0, "FreeRDP_Workarea" },
+       { FreeRDP_DesktopOrientation, 1, "FreeRDP_DesktopOrientation" },
+       { FreeRDP_ProxyPort, 1, "FreeRDP_ProxyPort" },
+       { FreeRDP_AcceptedCertLength, 3, "FreeRDP_AcceptedCertLength" },
+       { FreeRDP_AuthenticationLevel, 3, "FreeRDP_AuthenticationLevel" },
+       { FreeRDP_AutoReconnectMaxRetries, 3, "FreeRDP_AutoReconnectMaxRetries" },
+       { FreeRDP_BitmapCacheV2NumCells, 3, "FreeRDP_BitmapCacheV2NumCells" },
+       { FreeRDP_BitmapCacheV3CodecId, 3, "FreeRDP_BitmapCacheV3CodecId" },
+       { FreeRDP_BitmapCacheVersion, 3, "FreeRDP_BitmapCacheVersion" },
+       { FreeRDP_BrushSupportLevel, 3, "FreeRDP_BrushSupportLevel" },
+       { FreeRDP_ChannelCount, 3, "FreeRDP_ChannelCount" },
+       { FreeRDP_ChannelDefArraySize, 3, "FreeRDP_ChannelDefArraySize" },
+       { FreeRDP_ClientBuild, 3, "FreeRDP_ClientBuild" },
+       { FreeRDP_ClientRandomLength, 3, "FreeRDP_ClientRandomLength" },
+       { FreeRDP_ClusterInfoFlags, 3, "FreeRDP_ClusterInfoFlags" },
+       { FreeRDP_ColorDepth, 3, "FreeRDP_ColorDepth" },
+       { FreeRDP_CompDeskSupportLevel, 3, "FreeRDP_CompDeskSupportLevel" },
+       { FreeRDP_CompressionLevel, 3, "FreeRDP_CompressionLevel" },
+       { FreeRDP_ConnectionType, 3, "FreeRDP_ConnectionType" },
+       { FreeRDP_CookieMaxLength, 3, "FreeRDP_CookieMaxLength" },
+       { FreeRDP_DesktopHeight, 3, "FreeRDP_DesktopHeight" },
+       { FreeRDP_DesktopPhysicalHeight, 3, "FreeRDP_DesktopPhysicalHeight" },
+       { FreeRDP_DesktopPhysicalWidth, 3, "FreeRDP_DesktopPhysicalWidth" },
+       { FreeRDP_DesktopPosX, 3, "FreeRDP_DesktopPosX" },
+       { FreeRDP_DesktopPosY, 3, "FreeRDP_DesktopPosY" },
+       { FreeRDP_DesktopScaleFactor, 3, "FreeRDP_DesktopScaleFactor" },
+       { FreeRDP_DesktopWidth, 3, "FreeRDP_DesktopWidth" },
+       { FreeRDP_DeviceArraySize, 3, "FreeRDP_DeviceArraySize" },
+       { FreeRDP_DeviceCount, 3, "FreeRDP_DeviceCount" },
+       { FreeRDP_DeviceScaleFactor, 3, "FreeRDP_DeviceScaleFactor" },
+       { FreeRDP_DrawNineGridCacheEntries, 3, "FreeRDP_DrawNineGridCacheEntries" },
+       { FreeRDP_DrawNineGridCacheSize, 3, "FreeRDP_DrawNineGridCacheSize" },
+       { FreeRDP_DynamicChannelArraySize, 3, "FreeRDP_DynamicChannelArraySize" },
+       { FreeRDP_DynamicChannelCount, 3, "FreeRDP_DynamicChannelCount" },
+       { FreeRDP_EarlyCapabilityFlags, 3, "FreeRDP_EarlyCapabilityFlags" },
+       { FreeRDP_EncryptionLevel, 3, "FreeRDP_EncryptionLevel" },
+       { FreeRDP_EncryptionMethods, 3, "FreeRDP_EncryptionMethods" },
+       { FreeRDP_ExtEncryptionMethods, 3, "FreeRDP_ExtEncryptionMethods" },
+       { FreeRDP_FrameAcknowledge, 3, "FreeRDP_FrameAcknowledge" },
+       { FreeRDP_GatewayAcceptedCertLength, 3, "FreeRDP_GatewayAcceptedCertLength" },
+       { FreeRDP_GatewayCredentialsSource, 3, "FreeRDP_GatewayCredentialsSource" },
+       { FreeRDP_GatewayPort, 3, "FreeRDP_GatewayPort" },
+       { FreeRDP_GatewayUsageMethod, 3, "FreeRDP_GatewayUsageMethod" },
+       { FreeRDP_GfxCapsFilter, 3, "FreeRDP_GfxCapsFilter" },
+       { FreeRDP_GlyphSupportLevel, 3, "FreeRDP_GlyphSupportLevel" },
+       { FreeRDP_JpegCodecId, 3, "FreeRDP_JpegCodecId" },
+       { FreeRDP_JpegQuality, 3, "FreeRDP_JpegQuality" },
+       { FreeRDP_KeyboardCodePage, 3, "FreeRDP_KeyboardCodePage" },
+       { FreeRDP_KeyboardFunctionKey, 3, "FreeRDP_KeyboardFunctionKey" },
+       { FreeRDP_KeyboardHook, 3, "FreeRDP_KeyboardHook" },
+       { FreeRDP_KeyboardLayout, 3, "FreeRDP_KeyboardLayout" },
+       { FreeRDP_KeyboardSubType, 3, "FreeRDP_KeyboardSubType" },
+       { FreeRDP_KeyboardType, 3, "FreeRDP_KeyboardType" },
+       { FreeRDP_LargePointerFlag, 3, "FreeRDP_LargePointerFlag" },
+       { FreeRDP_LoadBalanceInfoLength, 3, "FreeRDP_LoadBalanceInfoLength" },
+       { FreeRDP_MaxTimeInCheckLoop, 3, "FreeRDP_MaxTimeInCheckLoop" },
+       { FreeRDP_MonitorCount, 3, "FreeRDP_MonitorCount" },
+       { FreeRDP_MonitorDefArraySize, 3, "FreeRDP_MonitorDefArraySize" },
+       { FreeRDP_MonitorLocalShiftX, 3, "FreeRDP_MonitorLocalShiftX" },
+       { FreeRDP_MonitorLocalShiftY, 3, "FreeRDP_MonitorLocalShiftY" },
+       { FreeRDP_MultifragMaxRequestSize, 3, "FreeRDP_MultifragMaxRequestSize" },
+       { FreeRDP_MultitransportFlags, 3, "FreeRDP_MultitransportFlags" },
+       { FreeRDP_NSCodecColorLossLevel, 3, "FreeRDP_NSCodecColorLossLevel" },
+       { FreeRDP_NSCodecId, 3, "FreeRDP_NSCodecId" },
+       { FreeRDP_NegotiationFlags, 3, "FreeRDP_NegotiationFlags" },
+       { FreeRDP_NumMonitorIds, 3, "FreeRDP_NumMonitorIds" },
+       { FreeRDP_OffscreenCacheEntries, 3, "FreeRDP_OffscreenCacheEntries" },
+       { FreeRDP_OffscreenCacheSize, 3, "FreeRDP_OffscreenCacheSize" },
+       { FreeRDP_OffscreenSupportLevel, 3, "FreeRDP_OffscreenSupportLevel" },
+       { FreeRDP_OsMajorType, 3, "FreeRDP_OsMajorType" },
+       { FreeRDP_OsMinorType, 3, "FreeRDP_OsMinorType" },
+       { FreeRDP_Password51Length, 3, "FreeRDP_Password51Length" },
+       { FreeRDP_PduSource, 3, "FreeRDP_PduSource" },
+       { FreeRDP_PercentScreen, 3, "FreeRDP_PercentScreen" },
+       { FreeRDP_PerformanceFlags, 3, "FreeRDP_PerformanceFlags" },
+       { FreeRDP_PointerCacheSize, 3, "FreeRDP_PointerCacheSize" },
+       { FreeRDP_PreconnectionId, 3, "FreeRDP_PreconnectionId" },
+       { FreeRDP_ProxyType, 3, "FreeRDP_ProxyType" },
+       { FreeRDP_RdpVersion, 3, "FreeRDP_RdpVersion" },
+       { FreeRDP_ReceivedCapabilitiesSize, 3, "FreeRDP_ReceivedCapabilitiesSize" },
+       { FreeRDP_RedirectedSessionId, 3, "FreeRDP_RedirectedSessionId" },
+       { FreeRDP_RedirectionAcceptedCertLength, 3, "FreeRDP_RedirectionAcceptedCertLength" },
+       { FreeRDP_RedirectionFlags, 3, "FreeRDP_RedirectionFlags" },
+       { FreeRDP_RedirectionPasswordLength, 3, "FreeRDP_RedirectionPasswordLength" },
+       { FreeRDP_RedirectionPreferType, 3, "FreeRDP_RedirectionPreferType" },
+       { FreeRDP_RedirectionTsvUrlLength, 3, "FreeRDP_RedirectionTsvUrlLength" },
+       { FreeRDP_RemoteAppNumIconCacheEntries, 3, "FreeRDP_RemoteAppNumIconCacheEntries" },
+       { FreeRDP_RemoteAppNumIconCaches, 3, "FreeRDP_RemoteAppNumIconCaches" },
+       { FreeRDP_RemoteApplicationExpandCmdLine, 3, "FreeRDP_RemoteApplicationExpandCmdLine" },
+       { FreeRDP_RemoteApplicationExpandWorkingDir, 3, "FreeRDP_RemoteApplicationExpandWorkingDir" },
+       { FreeRDP_RemoteApplicationSupportLevel, 3, "FreeRDP_RemoteApplicationSupportLevel" },
+       { FreeRDP_RemoteApplicationSupportMask, 3, "FreeRDP_RemoteApplicationSupportMask" },
+       { FreeRDP_RemoteFxCaptureFlags, 3, "FreeRDP_RemoteFxCaptureFlags" },
+       { FreeRDP_RemoteFxCodecId, 3, "FreeRDP_RemoteFxCodecId" },
+       { FreeRDP_RemoteFxCodecMode, 3, "FreeRDP_RemoteFxCodecMode" },
+       { FreeRDP_RemoteWndSupportLevel, 3, "FreeRDP_RemoteWndSupportLevel" },
+       { FreeRDP_RequestedProtocols, 3, "FreeRDP_RequestedProtocols" },
+       { FreeRDP_SelectedProtocol, 3, "FreeRDP_SelectedProtocol" },
+       { FreeRDP_ServerCertificateLength, 3, "FreeRDP_ServerCertificateLength" },
+       { FreeRDP_ServerPort, 3, "FreeRDP_ServerPort" },
+       { FreeRDP_ServerRandomLength, 3, "FreeRDP_ServerRandomLength" },
+       { FreeRDP_ShareId, 3, "FreeRDP_ShareId" },
+       { FreeRDP_SmartSizingHeight, 3, "FreeRDP_SmartSizingHeight" },
+       { FreeRDP_SmartSizingWidth, 3, "FreeRDP_SmartSizingWidth" },
+       { FreeRDP_StaticChannelArraySize, 3, "FreeRDP_StaticChannelArraySize" },
+       { FreeRDP_StaticChannelCount, 3, "FreeRDP_StaticChannelCount" },
+       { FreeRDP_TargetNetAddressCount, 3, "FreeRDP_TargetNetAddressCount" },
+       { FreeRDP_TcpAckTimeout, 3, "FreeRDP_TcpAckTimeout" },
+       { FreeRDP_TcpKeepAliveDelay, 3, "FreeRDP_TcpKeepAliveDelay" },
+       { FreeRDP_TcpKeepAliveInterval, 3, "FreeRDP_TcpKeepAliveInterval" },
+       { FreeRDP_TcpKeepAliveRetries, 3, "FreeRDP_TcpKeepAliveRetries" },
+       { FreeRDP_TlsSecLevel, 3, "FreeRDP_TlsSecLevel" },
+       { FreeRDP_VirtualChannelChunkSize, 3, "FreeRDP_VirtualChannelChunkSize" },
+       { FreeRDP_VirtualChannelCompressionFlags, 3, "FreeRDP_VirtualChannelCompressionFlags" },
+       { FreeRDP_XPan, 4, "FreeRDP_XPan" },
+       { FreeRDP_YPan, 4, "FreeRDP_YPan" },
+       { FreeRDP_ParentWindowId, 5, "FreeRDP_ParentWindowId" },
+       { FreeRDP_AcceptedCert, 7, "FreeRDP_AcceptedCert" },
+       { FreeRDP_AllowedTlsCiphers, 7, "FreeRDP_AllowedTlsCiphers" },
+       { FreeRDP_AlternateShell, 7, "FreeRDP_AlternateShell" },
+       { FreeRDP_AssistanceFile, 7, "FreeRDP_AssistanceFile" },
+       { FreeRDP_AuthenticationServiceClass, 7, "FreeRDP_AuthenticationServiceClass" },
+       { FreeRDP_CertificateAcceptedFingerprints, 7, "FreeRDP_CertificateAcceptedFingerprints" },
+       { FreeRDP_CertificateContent, 7, "FreeRDP_CertificateContent" },
+       { FreeRDP_CertificateFile, 7, "FreeRDP_CertificateFile" },
+       { FreeRDP_CertificateName, 7, "FreeRDP_CertificateName" },
+       { FreeRDP_ClientAddress, 7, "FreeRDP_ClientAddress" },
+       { FreeRDP_ClientDir, 7, "FreeRDP_ClientDir" },
+       { FreeRDP_ClientHostname, 7, "FreeRDP_ClientHostname" },
+       { FreeRDP_ClientProductId, 7, "FreeRDP_ClientProductId" },
+       { FreeRDP_ComputerName, 7, "FreeRDP_ComputerName" },
+       { FreeRDP_ConfigPath, 7, "FreeRDP_ConfigPath" },
+       { FreeRDP_ConnectionFile, 7, "FreeRDP_ConnectionFile" },
+       { FreeRDP_CurrentPath, 7, "FreeRDP_CurrentPath" },
+       { FreeRDP_Domain, 7, "FreeRDP_Domain" },
+       { FreeRDP_DrivesToRedirect, 7, "FreeRDP_DrivesToRedirect" },
+       { FreeRDP_DumpRemoteFxFile, 7, "FreeRDP_DumpRemoteFxFile" },
+       { FreeRDP_DynamicDSTTimeZoneKeyName, 7, "FreeRDP_DynamicDSTTimeZoneKeyName" },
+       { FreeRDP_GatewayAcceptedCert, 7, "FreeRDP_GatewayAcceptedCert" },
+       { FreeRDP_GatewayAccessToken, 7, "FreeRDP_GatewayAccessToken" },
+       { FreeRDP_GatewayDomain, 7, "FreeRDP_GatewayDomain" },
+       { FreeRDP_GatewayHostname, 7, "FreeRDP_GatewayHostname" },
+       { FreeRDP_GatewayPassword, 7, "FreeRDP_GatewayPassword" },
+       { FreeRDP_GatewayUsername, 7, "FreeRDP_GatewayUsername" },
+       { FreeRDP_HomePath, 7, "FreeRDP_HomePath" },
+       { FreeRDP_ImeFileName, 7, "FreeRDP_ImeFileName" },
+       { FreeRDP_KerberosKdc, 7, "FreeRDP_KerberosKdc" },
+       { FreeRDP_KerberosRealm, 7, "FreeRDP_KerberosRealm" },
+       { FreeRDP_NtlmSamFile, 7, "FreeRDP_NtlmSamFile" },
+       { FreeRDP_Password, 7, "FreeRDP_Password" },
+       { FreeRDP_PasswordHash, 7, "FreeRDP_PasswordHash" },
+       { FreeRDP_PlayRemoteFxFile, 7, "FreeRDP_PlayRemoteFxFile" },
+       { FreeRDP_PreconnectionBlob, 7, "FreeRDP_PreconnectionBlob" },
+       { FreeRDP_PrivateKeyContent, 7, "FreeRDP_PrivateKeyContent" },
+       { FreeRDP_PrivateKeyFile, 7, "FreeRDP_PrivateKeyFile" },
+       { FreeRDP_ProxyHostname, 7, "FreeRDP_ProxyHostname" },
+       { FreeRDP_ProxyPassword, 7, "FreeRDP_ProxyPassword" },
+       { FreeRDP_ProxyUsername, 7, "FreeRDP_ProxyUsername" },
+       { FreeRDP_RDP2TCPArgs, 7, "FreeRDP_RDP2TCPArgs" },
+       { FreeRDP_RdpKeyContent, 7, "FreeRDP_RdpKeyContent" },
+       { FreeRDP_RdpKeyFile, 7, "FreeRDP_RdpKeyFile" },
+       { FreeRDP_RedirectionAcceptedCert, 7, "FreeRDP_RedirectionAcceptedCert" },
+       { FreeRDP_RedirectionDomain, 7, "FreeRDP_RedirectionDomain" },
+       { FreeRDP_RedirectionTargetFQDN, 7, "FreeRDP_RedirectionTargetFQDN" },
+       { FreeRDP_RedirectionTargetNetBiosName, 7, "FreeRDP_RedirectionTargetNetBiosName" },
+       { FreeRDP_RedirectionUsername, 7, "FreeRDP_RedirectionUsername" },
+       { FreeRDP_RemoteApplicationCmdLine, 7, "FreeRDP_RemoteApplicationCmdLine" },
+       { FreeRDP_RemoteApplicationFile, 7, "FreeRDP_RemoteApplicationFile" },
+       { FreeRDP_RemoteApplicationGuid, 7, "FreeRDP_RemoteApplicationGuid" },
+       { FreeRDP_RemoteApplicationIcon, 7, "FreeRDP_RemoteApplicationIcon" },
+       { FreeRDP_RemoteApplicationName, 7, "FreeRDP_RemoteApplicationName" },
+       { FreeRDP_RemoteApplicationProgram, 7, "FreeRDP_RemoteApplicationProgram" },
+       { FreeRDP_RemoteApplicationWorkingDir, 7, "FreeRDP_RemoteApplicationWorkingDir" },
+       { FreeRDP_RemoteAssistancePassStub, 7, "FreeRDP_RemoteAssistancePassStub" },
+       { FreeRDP_RemoteAssistancePassword, 7, "FreeRDP_RemoteAssistancePassword" },
+       { FreeRDP_RemoteAssistanceRCTicket, 7, "FreeRDP_RemoteAssistanceRCTicket" },
+       { FreeRDP_RemoteAssistanceSessionId, 7, "FreeRDP_RemoteAssistanceSessionId" },
+       { FreeRDP_ServerHostname, 7, "FreeRDP_ServerHostname" },
+       { FreeRDP_ShellWorkingDirectory, 7, "FreeRDP_ShellWorkingDirectory" },
+       { FreeRDP_TargetNetAddress, 7, "FreeRDP_TargetNetAddress" },
+       { FreeRDP_Username, 7, "FreeRDP_Username" },
+       { FreeRDP_WindowTitle, 7, "FreeRDP_WindowTitle" },
+       { FreeRDP_WmClass, 7, "FreeRDP_WmClass" },
+       { FreeRDP_BitmapCacheV2CellInfo, 8, "FreeRDP_BitmapCacheV2CellInfo" },
+       { FreeRDP_ChannelDefArray, 8, "FreeRDP_ChannelDefArray" },
+       { FreeRDP_ClientAutoReconnectCookie, 8, "FreeRDP_ClientAutoReconnectCookie" },
+       { FreeRDP_ClientRandom, 8, "FreeRDP_ClientRandom" },
+       { FreeRDP_ClientTimeZone, 8, "FreeRDP_ClientTimeZone" },
+       { FreeRDP_DeviceArray, 8, "FreeRDP_DeviceArray" },
+       { FreeRDP_DynamicChannelArray, 8, "FreeRDP_DynamicChannelArray" },
+       { FreeRDP_FragCache, 8, "FreeRDP_FragCache" },
+       { FreeRDP_GlyphCache, 8, "FreeRDP_GlyphCache" },
+       { FreeRDP_LoadBalanceInfo, 8, "FreeRDP_LoadBalanceInfo" },
+       { FreeRDP_MonitorDefArray, 8, "FreeRDP_MonitorDefArray" },
+       { FreeRDP_MonitorIds, 8, "FreeRDP_MonitorIds" },
+       { FreeRDP_OrderSupport, 8, "FreeRDP_OrderSupport" },
+       { FreeRDP_Password51, 8, "FreeRDP_Password51" },
+       { FreeRDP_RdpServerCertificate, 8, "FreeRDP_RdpServerCertificate" },
+       { FreeRDP_RdpServerRsaKey, 8, "FreeRDP_RdpServerRsaKey" },
+       { FreeRDP_ReceivedCapabilities, 8, "FreeRDP_ReceivedCapabilities" },
+       { FreeRDP_RedirectionPassword, 8, "FreeRDP_RedirectionPassword" },
+       { FreeRDP_RedirectionTsvUrl, 8, "FreeRDP_RedirectionTsvUrl" },
+       { FreeRDP_ServerAutoReconnectCookie, 8, "FreeRDP_ServerAutoReconnectCookie" },
+       { FreeRDP_ServerCertificate, 8, "FreeRDP_ServerCertificate" },
+       { FreeRDP_ServerRandom, 8, "FreeRDP_ServerRandom" },
+       { FreeRDP_StaticChannelArray, 8, "FreeRDP_StaticChannelArray" },
+       { FreeRDP_TargetNetAddresses, 8, "FreeRDP_TargetNetAddresses" },
+       { FreeRDP_TargetNetPorts, 8, "FreeRDP_TargetNetPorts" },
+       { FreeRDP_instance, 8, "FreeRDP_instance" },
+};
+
+SSIZE_T freerdp_settings_get_key_for_name(const char* value)
+{
+       size_t x;
+       for (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)
+{
+       size_t x;
+       for (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;
+}
+
+SSIZE_T freerdp_settings_get_type_for_key(size_t key)
+{
+       size_t x;
+       for (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(size_t key)
+{
+       size_t x;
+       for (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;
+}

diff --git a/libfreerdp/core/test/settings_property_lists.h b/libfreerdp/core/test/settings_property_lists.h
index 85760e2..c44018e 100644 (file)
--- a/libfreerdp/core/test/settings_property_lists.h
+++ b/libfreerdp/core/test/settings_property_lists.h
@@ -3,169 +3,169 @@
 
 #define have_bool_list_indices
 static const size_t bool_list_indices[] = {
-       FreeRDP_ServerMode,
-       FreeRDP_WaitForOutputBufferFlush,
-       FreeRDP_NetworkAutoDetect,
-       FreeRDP_SupportAsymetricKeys,
-       FreeRDP_SupportErrorInfoPdu,
-       FreeRDP_SupportStatusInfoPdu,
-       FreeRDP_SupportMonitorLayoutPdu,
-       FreeRDP_SupportGraphicsPipeline,
-       FreeRDP_SupportDynamicTimeZone,
-       FreeRDP_SupportHeartbeatPdu,
-       FreeRDP_UseRdpSecurityLayer,
-       FreeRDP_ConsoleSession,
-       FreeRDP_SpanMonitors,
-       FreeRDP_UseMultimon,
-       FreeRDP_ForceMultimon,
-       FreeRDP_ListMonitors,
-       FreeRDP_HasMonitorAttributes,
-       FreeRDP_SupportMultitransport,
+       FreeRDP_AllowCacheWaitingList,
+       FreeRDP_AllowDesktopComposition,
+       FreeRDP_AllowFontSmoothing,
+       FreeRDP_AllowUnanouncedOrdersFromServer,
+       FreeRDP_AltSecFrameMarkerSupport,
+       FreeRDP_AsyncChannels,
+       FreeRDP_AsyncInput,
+       FreeRDP_AsyncUpdate,
+       FreeRDP_AudioCapture,
+       FreeRDP_AudioPlayback,
+       FreeRDP_Authentication,
+       FreeRDP_AuthenticationOnly,
+       FreeRDP_AutoAcceptCertificate,
+       FreeRDP_AutoDenyCertificate,
        FreeRDP_AutoLogonEnabled,
+       FreeRDP_AutoReconnectionEnabled,
+       FreeRDP_BitmapCacheEnabled,
+       FreeRDP_BitmapCachePersistEnabled,
+       FreeRDP_BitmapCacheV3Enabled,
+       FreeRDP_BitmapCompressionDisabled,
+       FreeRDP_ColorPointerFlag,
        FreeRDP_CompressionEnabled,
+       FreeRDP_ConsoleSession,
+       FreeRDP_CredentialsFromStdin,
+       FreeRDP_Decorations,
+       FreeRDP_DesktopResize,
+       FreeRDP_DeviceRedirection,
+       FreeRDP_DisableCredentialsDelegation,
        FreeRDP_DisableCtrlAltDel,
-       FreeRDP_EnableWindowsKey,
-       FreeRDP_MaximizeShell,
-       FreeRDP_LogonNotify,
-       FreeRDP_LogonErrors,
-       FreeRDP_MouseAttached,
-       FreeRDP_MouseHasWheel,
-       FreeRDP_RemoteConsoleAudio,
-       FreeRDP_AudioPlayback,
-       FreeRDP_AudioCapture,
-       FreeRDP_VideoDisable,
-       FreeRDP_PasswordIsSmartcardPin,
-       FreeRDP_UsingSavedCredentials,
-       FreeRDP_ForceEncryptedCsPdu,
-       FreeRDP_HiDefRemoteApp,
-       FreeRDP_IPv6Enabled,
-       FreeRDP_AutoReconnectionEnabled,
-       FreeRDP_PrintReconnectCookie,
-       FreeRDP_DynamicDaylightTimeDisabled,
-       FreeRDP_AllowFontSmoothing,
-       FreeRDP_DisableWallpaper,
+       FreeRDP_DisableCursorBlinking,
+       FreeRDP_DisableCursorShadow,
        FreeRDP_DisableFullWindowDrag,
        FreeRDP_DisableMenuAnims,
+       FreeRDP_DisableRemoteAppCapsCheck,
        FreeRDP_DisableThemes,
-       FreeRDP_DisableCursorShadow,
-       FreeRDP_DisableCursorBlinking,
-       FreeRDP_AllowDesktopComposition,
-       FreeRDP_RemoteAssistanceMode,
+       FreeRDP_DisableWallpaper,
+       FreeRDP_DrawAllowColorSubsampling,
+       FreeRDP_DrawAllowDynamicColorFidelity,
+       FreeRDP_DrawAllowSkipAlpha,
+       FreeRDP_DrawGdiPlusCacheEnabled,
+       FreeRDP_DrawGdiPlusEnabled,
+       FreeRDP_DrawNineGridEnabled,
+       FreeRDP_DumpRemoteFx,
+       FreeRDP_DynamicDaylightTimeDisabled,
+       FreeRDP_DynamicResolutionUpdate,
+       FreeRDP_EmbeddedWindow,
+       FreeRDP_EnableWindowsKey,
        FreeRDP_EncomspVirtualChannel,
-       FreeRDP_RemdeskVirtualChannel,
-       FreeRDP_LyncRdpMode,
-       FreeRDP_RemoteAssistanceRequestControl,
-       FreeRDP_TlsSecurity,
-       FreeRDP_NlaSecurity,
-       FreeRDP_RdpSecurity,
        FreeRDP_ExtSecurity,
-       FreeRDP_Authentication,
-       FreeRDP_NegotiateSecurityLayer,
-       FreeRDP_RestrictedAdminModeRequired,
-       FreeRDP_DisableCredentialsDelegation,
-       FreeRDP_VmConnectMode,
-       FreeRDP_FIPSMode,
-       FreeRDP_MstscCookieMode,
-       FreeRDP_SendPreconnectionPdu,
-       FreeRDP_SmartcardLogon,
-       FreeRDP_PromptForCredentials,
-       FreeRDP_IgnoreCertificate,
        FreeRDP_ExternalCertificateManagement,
-       FreeRDP_AutoAcceptCertificate,
-       FreeRDP_AutoDenyCertificate,
-       FreeRDP_Workarea,
+       FreeRDP_FIPSMode,
+       FreeRDP_FastPathInput,
+       FreeRDP_FastPathOutput,
+       FreeRDP_ForceEncryptedCsPdu,
+       FreeRDP_ForceMultimon,
+       FreeRDP_FrameMarkerCommandEnabled,
        FreeRDP_Fullscreen,
-       FreeRDP_GrabKeyboard,
-       FreeRDP_Decorations,
-       FreeRDP_MouseMotion,
-       FreeRDP_AsyncInput,
-       FreeRDP_AsyncUpdate,
-       FreeRDP_AsyncChannels,
-       FreeRDP_ToggleFullscreen,
-       FreeRDP_EmbeddedWindow,
-       FreeRDP_SmartSizing,
-       FreeRDP_PercentScreenUseWidth,
-       FreeRDP_PercentScreenUseHeight,
-       FreeRDP_DynamicResolutionUpdate,
-       FreeRDP_SoftwareGdi,
-       FreeRDP_LocalConnection,
-       FreeRDP_AuthenticationOnly,
-       FreeRDP_CredentialsFromStdin,
-       FreeRDP_UnmapButtons,
-       FreeRDP_OldLicenseBehaviour,
-       FreeRDP_DumpRemoteFx,
-       FreeRDP_PlayRemoteFx,
-       FreeRDP_GatewayUseSameCredentials,
-       FreeRDP_GatewayEnabled,
        FreeRDP_GatewayBypassLocal,
-       FreeRDP_GatewayRpcTransport,
+       FreeRDP_GatewayEnabled,
        FreeRDP_GatewayHttpTransport,
+       FreeRDP_GatewayRpcTransport,
        FreeRDP_GatewayUdpTransport,
-       FreeRDP_RemoteApplicationMode,
-       FreeRDP_DisableRemoteAppCapsCheck,
-       FreeRDP_RemoteAppLanguageBarSupported,
-       FreeRDP_RefreshRect,
-       FreeRDP_SuppressOutput,
-       FreeRDP_FastPathOutput,
-       FreeRDP_SaltedChecksum,
+       FreeRDP_GatewayUseSameCredentials,
+       FreeRDP_GfxAVC444,
+       FreeRDP_GfxAVC444v2,
+       FreeRDP_GfxH264,
+       FreeRDP_GfxProgressive,
+       FreeRDP_GfxProgressiveV2,
+       FreeRDP_GfxSendQoeAck,
+       FreeRDP_GfxSmallCache,
+       FreeRDP_GfxThinClient,
+       FreeRDP_GrabKeyboard,
+       FreeRDP_HasExtendedMouseEvent,
+       FreeRDP_HasHorizontalWheel,
+       FreeRDP_HasMonitorAttributes,
+       FreeRDP_HiDefRemoteApp,
+       FreeRDP_IPv6Enabled,
+       FreeRDP_IgnoreCertificate,
+       FreeRDP_JpegCodec,
+       FreeRDP_ListMonitors,
+       FreeRDP_LocalConnection,
+       FreeRDP_LogonErrors,
+       FreeRDP_LogonNotify,
        FreeRDP_LongCredentialsSupported,
-       FreeRDP_NoBitmapCompressionHeader,
-       FreeRDP_BitmapCompressionDisabled,
-       FreeRDP_DesktopResize,
-       FreeRDP_DrawAllowDynamicColorFidelity,
-       FreeRDP_DrawAllowColorSubsampling,
-       FreeRDP_DrawAllowSkipAlpha,
-       FreeRDP_BitmapCacheV3Enabled,
-       FreeRDP_AltSecFrameMarkerSupport,
-       FreeRDP_AllowUnanouncedOrdersFromServer,
-       FreeRDP_BitmapCacheEnabled,
-       FreeRDP_AllowCacheWaitingList,
-       FreeRDP_BitmapCachePersistEnabled,
-       FreeRDP_ColorPointerFlag,
-       FreeRDP_UnicodeInput,
-       FreeRDP_FastPathInput,
-       FreeRDP_MultiTouchInput,
+       FreeRDP_LyncRdpMode,
+       FreeRDP_MaximizeShell,
+       FreeRDP_MouseAttached,
+       FreeRDP_MouseHasWheel,
+       FreeRDP_MouseMotion,
+       FreeRDP_MstscCookieMode,
        FreeRDP_MultiTouchGestures,
-       FreeRDP_HasHorizontalWheel,
-       FreeRDP_HasExtendedMouseEvent,
-       FreeRDP_SoundBeepsEnabled,
-       FreeRDP_SurfaceCommandsEnabled,
-       FreeRDP_FrameMarkerCommandEnabled,
-       FreeRDP_SurfaceFrameMarkerEnabled,
-       FreeRDP_RemoteFxOnly,
-       FreeRDP_RemoteFxCodec,
-       FreeRDP_RemoteFxImageCodec,
+       FreeRDP_MultiTouchInput,
        FreeRDP_NSCodec,
-       FreeRDP_NSCodecAllowSubsampling,
        FreeRDP_NSCodecAllowDynamicColorFidelity,
-       FreeRDP_JpegCodec,
-       FreeRDP_GfxThinClient,
-       FreeRDP_GfxSmallCache,
-       FreeRDP_GfxProgressive,
-       FreeRDP_GfxProgressiveV2,
-       FreeRDP_GfxH264,
-       FreeRDP_GfxAVC444,
-       FreeRDP_GfxSendQoeAck,
-       FreeRDP_GfxAVC444v2,
-       FreeRDP_DrawNineGridEnabled,
-       FreeRDP_DrawGdiPlusEnabled,
-       FreeRDP_DrawGdiPlusCacheEnabled,
-       FreeRDP_DeviceRedirection,
+       FreeRDP_NSCodecAllowSubsampling,
+       FreeRDP_NegotiateSecurityLayer,
+       FreeRDP_NetworkAutoDetect,
+       FreeRDP_NlaSecurity,
+       FreeRDP_NoBitmapCompressionHeader,
+       FreeRDP_OldLicenseBehaviour,
+       FreeRDP_PasswordIsSmartcardPin,
+       FreeRDP_PercentScreenUseHeight,
+       FreeRDP_PercentScreenUseWidth,
+       FreeRDP_PlayRemoteFx,
+       FreeRDP_PreferIPv6OverIPv4,
+       FreeRDP_PrintReconnectCookie,
+       FreeRDP_PromptForCredentials,
+       FreeRDP_RdpSecurity,
+       FreeRDP_RedirectClipboard,
        FreeRDP_RedirectDrives,
        FreeRDP_RedirectHomeDrive,
-       FreeRDP_RedirectSmartCards,
+       FreeRDP_RedirectParallelPorts,
        FreeRDP_RedirectPrinters,
        FreeRDP_RedirectSerialPorts,
-       FreeRDP_RedirectParallelPorts,
-       FreeRDP_PreferIPv6OverIPv4,
-       FreeRDP_RedirectClipboard,
+       FreeRDP_RedirectSmartCards,
+       FreeRDP_RefreshRect,
+       FreeRDP_RemdeskVirtualChannel,
+       FreeRDP_RemoteAppLanguageBarSupported,
+       FreeRDP_RemoteApplicationMode,
+       FreeRDP_RemoteAssistanceMode,
+       FreeRDP_RemoteAssistanceRequestControl,
+       FreeRDP_RemoteConsoleAudio,
+       FreeRDP_RemoteFxCodec,
+       FreeRDP_RemoteFxImageCodec,
+       FreeRDP_RemoteFxOnly,
+       FreeRDP_RestrictedAdminModeRequired,
+       FreeRDP_SaltedChecksum,
+       FreeRDP_SendPreconnectionPdu,
+       FreeRDP_ServerMode,
+       FreeRDP_SmartSizing,
+       FreeRDP_SmartcardLogon,
+       FreeRDP_SoftwareGdi,
+       FreeRDP_SoundBeepsEnabled,
+       FreeRDP_SpanMonitors,
+       FreeRDP_SupportAsymetricKeys,
+       FreeRDP_SupportDisplayControl,
        FreeRDP_SupportDynamicChannels,
+       FreeRDP_SupportDynamicTimeZone,
        FreeRDP_SupportEchoChannel,
-       FreeRDP_SupportDisplayControl,
+       FreeRDP_SupportErrorInfoPdu,
        FreeRDP_SupportGeometryTracking,
+       FreeRDP_SupportGraphicsPipeline,
+       FreeRDP_SupportHeartbeatPdu,
+       FreeRDP_SupportMonitorLayoutPdu,
+       FreeRDP_SupportMultitransport,
        FreeRDP_SupportSSHAgentChannel,
+       FreeRDP_SupportStatusInfoPdu,
        FreeRDP_SupportVideoOptimized,
+       FreeRDP_SuppressOutput,
+       FreeRDP_SurfaceCommandsEnabled,
+       FreeRDP_SurfaceFrameMarkerEnabled,
        FreeRDP_TcpKeepAlive,
+       FreeRDP_TlsSecurity,
+       FreeRDP_ToggleFullscreen,
+       FreeRDP_UnicodeInput,
+       FreeRDP_UnmapButtons,
+       FreeRDP_UseMultimon,
+       FreeRDP_UseRdpSecurityLayer,
+       FreeRDP_UsingSavedCredentials,
+       FreeRDP_VideoDisable,
+       FreeRDP_VmConnectMode,
+       FreeRDP_WaitForOutputBufferFlush,
+       FreeRDP_Workarea,
 };
 
 #define have_uint16_list_indices
@@ -176,117 +176,117 @@ static const size_t uint16_list_indices[] = {
 
 #define have_uint32_list_indices
 static const size_t uint32_list_indices[] = {
-       FreeRDP_ShareId,
-       FreeRDP_PduSource,
-       FreeRDP_ServerPort,
-       FreeRDP_MaxTimeInCheckLoop,
        FreeRDP_AcceptedCertLength,
-       FreeRDP_RdpVersion,
-       FreeRDP_DesktopWidth,
-       FreeRDP_DesktopHeight,
+       FreeRDP_AuthenticationLevel,
+       FreeRDP_AutoReconnectMaxRetries,
+       FreeRDP_BitmapCacheV2NumCells,
+       FreeRDP_BitmapCacheV3CodecId,
+       FreeRDP_BitmapCacheVersion,
+       FreeRDP_BrushSupportLevel,
+       FreeRDP_ChannelCount,
+       FreeRDP_ChannelDefArraySize,
+       FreeRDP_ClientBuild,
+       FreeRDP_ClientRandomLength,
+       FreeRDP_ClusterInfoFlags,
        FreeRDP_ColorDepth,
+       FreeRDP_CompDeskSupportLevel,
+       FreeRDP_CompressionLevel,
        FreeRDP_ConnectionType,
-       FreeRDP_ClientBuild,
-       FreeRDP_EarlyCapabilityFlags,
-       FreeRDP_DesktopPhysicalWidth,
+       FreeRDP_CookieMaxLength,
+       FreeRDP_DesktopHeight,
        FreeRDP_DesktopPhysicalHeight,
+       FreeRDP_DesktopPhysicalWidth,
+       FreeRDP_DesktopPosX,
+       FreeRDP_DesktopPosY,
        FreeRDP_DesktopScaleFactor,
+       FreeRDP_DesktopWidth,
+       FreeRDP_DeviceArraySize,
+       FreeRDP_DeviceCount,
        FreeRDP_DeviceScaleFactor,
+       FreeRDP_DrawNineGridCacheEntries,
+       FreeRDP_DrawNineGridCacheSize,
+       FreeRDP_DynamicChannelArraySize,
+       FreeRDP_DynamicChannelCount,
+       FreeRDP_EarlyCapabilityFlags,
+       FreeRDP_EncryptionLevel,
        FreeRDP_EncryptionMethods,
        FreeRDP_ExtEncryptionMethods,
-       FreeRDP_EncryptionLevel,
-       FreeRDP_ServerRandomLength,
-       FreeRDP_ServerCertificateLength,
-       FreeRDP_ClientRandomLength,
-       FreeRDP_ChannelCount,
-       FreeRDP_ChannelDefArraySize,
-       FreeRDP_ClusterInfoFlags,
-       FreeRDP_RedirectedSessionId,
+       FreeRDP_FrameAcknowledge,
+       FreeRDP_GatewayAcceptedCertLength,
+       FreeRDP_GatewayCredentialsSource,
+       FreeRDP_GatewayPort,
+       FreeRDP_GatewayUsageMethod,
+       FreeRDP_GfxCapsFilter,
+       FreeRDP_GlyphSupportLevel,
+       FreeRDP_JpegCodecId,
+       FreeRDP_JpegQuality,
+       FreeRDP_KeyboardCodePage,
+       FreeRDP_KeyboardFunctionKey,
+       FreeRDP_KeyboardHook,
+       FreeRDP_KeyboardLayout,
+       FreeRDP_KeyboardSubType,
+       FreeRDP_KeyboardType,
+       FreeRDP_LargePointerFlag,
+       FreeRDP_LoadBalanceInfoLength,
+       FreeRDP_MaxTimeInCheckLoop,
        FreeRDP_MonitorCount,
        FreeRDP_MonitorDefArraySize,
-       FreeRDP_DesktopPosX,
-       FreeRDP_DesktopPosY,
-       FreeRDP_NumMonitorIds,
        FreeRDP_MonitorLocalShiftX,
        FreeRDP_MonitorLocalShiftY,
+       FreeRDP_MultifragMaxRequestSize,
        FreeRDP_MultitransportFlags,
-       FreeRDP_CompressionLevel,
-       FreeRDP_AutoReconnectMaxRetries,
-       FreeRDP_PerformanceFlags,
-       FreeRDP_RequestedProtocols,
-       FreeRDP_SelectedProtocol,
+       FreeRDP_NSCodecColorLossLevel,
+       FreeRDP_NSCodecId,
        FreeRDP_NegotiationFlags,
-       FreeRDP_AuthenticationLevel,
-       FreeRDP_TlsSecLevel,
-       FreeRDP_CookieMaxLength,
+       FreeRDP_NumMonitorIds,
+       FreeRDP_OffscreenCacheEntries,
+       FreeRDP_OffscreenCacheSize,
+       FreeRDP_OffscreenSupportLevel,
+       FreeRDP_OsMajorType,
+       FreeRDP_OsMinorType,
+       FreeRDP_Password51Length,
+       FreeRDP_PduSource,
+       FreeRDP_PercentScreen,
+       FreeRDP_PerformanceFlags,
+       FreeRDP_PointerCacheSize,
        FreeRDP_PreconnectionId,
+       FreeRDP_ProxyType,
+       FreeRDP_RdpVersion,
+       FreeRDP_ReceivedCapabilitiesSize,
+       FreeRDP_RedirectedSessionId,
+       FreeRDP_RedirectionAcceptedCertLength,
        FreeRDP_RedirectionFlags,
-       FreeRDP_LoadBalanceInfoLength,
        FreeRDP_RedirectionPasswordLength,
-       FreeRDP_RedirectionTsvUrlLength,
-       FreeRDP_TargetNetAddressCount,
-       FreeRDP_RedirectionAcceptedCertLength,
        FreeRDP_RedirectionPreferType,
-       FreeRDP_Password51Length,
-       FreeRDP_PercentScreen,
-       FreeRDP_SmartSizingWidth,
-       FreeRDP_SmartSizingHeight,
-       FreeRDP_GatewayUsageMethod,
-       FreeRDP_GatewayPort,
-       FreeRDP_GatewayCredentialsSource,
-       FreeRDP_GatewayAcceptedCertLength,
-       FreeRDP_ProxyType,
+       FreeRDP_RedirectionTsvUrlLength,
+       FreeRDP_RemoteAppNumIconCacheEntries,
+       FreeRDP_RemoteAppNumIconCaches,
        FreeRDP_RemoteApplicationExpandCmdLine,
        FreeRDP_RemoteApplicationExpandWorkingDir,
-       FreeRDP_RemoteAppNumIconCaches,
-       FreeRDP_RemoteAppNumIconCacheEntries,
-       FreeRDP_RemoteWndSupportLevel,
        FreeRDP_RemoteApplicationSupportLevel,
        FreeRDP_RemoteApplicationSupportMask,
-       FreeRDP_ReceivedCapabilitiesSize,
-       FreeRDP_OsMajorType,
-       FreeRDP_OsMinorType,
-       FreeRDP_BitmapCacheVersion,
-       FreeRDP_BitmapCacheV2NumCells,
-       FreeRDP_PointerCacheSize,
-       FreeRDP_KeyboardCodePage,
-       FreeRDP_KeyboardLayout,
-       FreeRDP_KeyboardType,
-       FreeRDP_KeyboardSubType,
-       FreeRDP_KeyboardFunctionKey,
-       FreeRDP_KeyboardHook,
-       FreeRDP_BrushSupportLevel,
-       FreeRDP_GlyphSupportLevel,
-       FreeRDP_OffscreenSupportLevel,
-       FreeRDP_OffscreenCacheSize,
-       FreeRDP_OffscreenCacheEntries,
-       FreeRDP_VirtualChannelCompressionFlags,
-       FreeRDP_VirtualChannelChunkSize,
-       FreeRDP_MultifragMaxRequestSize,
-       FreeRDP_LargePointerFlag,
-       FreeRDP_CompDeskSupportLevel,
+       FreeRDP_RemoteFxCaptureFlags,
        FreeRDP_RemoteFxCodecId,
        FreeRDP_RemoteFxCodecMode,
-       FreeRDP_RemoteFxCaptureFlags,
-       FreeRDP_NSCodecId,
-       FreeRDP_FrameAcknowledge,
-       FreeRDP_NSCodecColorLossLevel,
-       FreeRDP_JpegCodecId,
-       FreeRDP_JpegQuality,
-       FreeRDP_GfxCapsFilter,
-       FreeRDP_BitmapCacheV3CodecId,
-       FreeRDP_DrawNineGridCacheSize,
-       FreeRDP_DrawNineGridCacheEntries,
-       FreeRDP_DeviceCount,
-       FreeRDP_DeviceArraySize,
-       FreeRDP_StaticChannelCount,
+       FreeRDP_RemoteWndSupportLevel,
+       FreeRDP_RequestedProtocols,
+       FreeRDP_SelectedProtocol,
+       FreeRDP_ServerCertificateLength,
+       FreeRDP_ServerPort,
+       FreeRDP_ServerRandomLength,
+       FreeRDP_ShareId,
+       FreeRDP_SmartSizingHeight,
+       FreeRDP_SmartSizingWidth,
        FreeRDP_StaticChannelArraySize,
-       FreeRDP_DynamicChannelCount,
-       FreeRDP_DynamicChannelArraySize,
-       FreeRDP_TcpKeepAliveRetries,
+       FreeRDP_StaticChannelCount,
+       FreeRDP_TargetNetAddressCount,
+       FreeRDP_TcpAckTimeout,
        FreeRDP_TcpKeepAliveDelay,
        FreeRDP_TcpKeepAliveInterval,
-       FreeRDP_TcpAckTimeout,
+       FreeRDP_TcpKeepAliveRetries,
+       FreeRDP_TlsSecLevel,
+       FreeRDP_VirtualChannelChunkSize,
+       FreeRDP_VirtualChannelCompressionFlags,
 };
 
 #define have_int32_list_indices
@@ -302,102 +302,102 @@ static const size_t uint64_list_indices[] = {
 
 #define have_string_list_indices
 static const size_t string_list_indices[] = {
-       FreeRDP_ServerHostname,
-       FreeRDP_Username,
-       FreeRDP_Password,
-       FreeRDP_Domain,
-       FreeRDP_PasswordHash,
        FreeRDP_AcceptedCert,
-       FreeRDP_ClientHostname,
-       FreeRDP_ClientProductId,
+       FreeRDP_AllowedTlsCiphers,
        FreeRDP_AlternateShell,
-       FreeRDP_ShellWorkingDirectory,
-       FreeRDP_ClientAddress,
-       FreeRDP_ClientDir,
-       FreeRDP_DynamicDSTTimeZoneKeyName,
-       FreeRDP_RemoteAssistanceSessionId,
-       FreeRDP_RemoteAssistancePassStub,
-       FreeRDP_RemoteAssistancePassword,
-       FreeRDP_RemoteAssistanceRCTicket,
+       FreeRDP_AssistanceFile,
        FreeRDP_AuthenticationServiceClass,
-       FreeRDP_AllowedTlsCiphers,
-       FreeRDP_NtlmSamFile,
-       FreeRDP_PreconnectionBlob,
-       FreeRDP_TargetNetAddress,
-       FreeRDP_RedirectionUsername,
-       FreeRDP_RedirectionDomain,
-       FreeRDP_RedirectionTargetFQDN,
-       FreeRDP_RedirectionTargetNetBiosName,
-       FreeRDP_RedirectionAcceptedCert,
-       FreeRDP_KerberosKdc,
-       FreeRDP_KerberosRealm,
-       FreeRDP_CertificateName,
-       FreeRDP_CertificateFile,
-       FreeRDP_PrivateKeyFile,
-       FreeRDP_RdpKeyFile,
-       FreeRDP_CertificateContent,
-       FreeRDP_PrivateKeyContent,
-       FreeRDP_RdpKeyContent,
        FreeRDP_CertificateAcceptedFingerprints,
-       FreeRDP_WindowTitle,
-       FreeRDP_WmClass,
+       FreeRDP_CertificateContent,
+       FreeRDP_CertificateFile,
+       FreeRDP_CertificateName,
+       FreeRDP_ClientAddress,
+       FreeRDP_ClientDir,
+       FreeRDP_ClientHostname,
+       FreeRDP_ClientProductId,
        FreeRDP_ComputerName,
-       FreeRDP_ConnectionFile,
-       FreeRDP_AssistanceFile,
-       FreeRDP_HomePath,
        FreeRDP_ConfigPath,
+       FreeRDP_ConnectionFile,
        FreeRDP_CurrentPath,
+       FreeRDP_Domain,
+       FreeRDP_DrivesToRedirect,
        FreeRDP_DumpRemoteFxFile,
-       FreeRDP_PlayRemoteFxFile,
+       FreeRDP_DynamicDSTTimeZoneKeyName,
+       FreeRDP_GatewayAcceptedCert,
+       FreeRDP_GatewayAccessToken,
+       FreeRDP_GatewayDomain,
        FreeRDP_GatewayHostname,
-       FreeRDP_GatewayUsername,
        FreeRDP_GatewayPassword,
-       FreeRDP_GatewayDomain,
-       FreeRDP_GatewayAccessToken,
-       FreeRDP_GatewayAcceptedCert,
+       FreeRDP_GatewayUsername,
+       FreeRDP_HomePath,
+       FreeRDP_ImeFileName,
+       FreeRDP_KerberosKdc,
+       FreeRDP_KerberosRealm,
+       FreeRDP_NtlmSamFile,
+       FreeRDP_Password,
+       FreeRDP_PasswordHash,
+       FreeRDP_PlayRemoteFxFile,
+       FreeRDP_PreconnectionBlob,
+       FreeRDP_PrivateKeyContent,
+       FreeRDP_PrivateKeyFile,
        FreeRDP_ProxyHostname,
-       FreeRDP_ProxyUsername,
        FreeRDP_ProxyPassword,
-       FreeRDP_RemoteApplicationName,
-       FreeRDP_RemoteApplicationIcon,
-       FreeRDP_RemoteApplicationProgram,
+       FreeRDP_ProxyUsername,
+       FreeRDP_RDP2TCPArgs,
+       FreeRDP_RdpKeyContent,
+       FreeRDP_RdpKeyFile,
+       FreeRDP_RedirectionAcceptedCert,
+       FreeRDP_RedirectionDomain,
+       FreeRDP_RedirectionTargetFQDN,
+       FreeRDP_RedirectionTargetNetBiosName,
+       FreeRDP_RedirectionUsername,
+       FreeRDP_RemoteApplicationCmdLine,
        FreeRDP_RemoteApplicationFile,
        FreeRDP_RemoteApplicationGuid,
-       FreeRDP_RemoteApplicationCmdLine,
+       FreeRDP_RemoteApplicationIcon,
+       FreeRDP_RemoteApplicationName,
+       FreeRDP_RemoteApplicationProgram,
        FreeRDP_RemoteApplicationWorkingDir,
-       FreeRDP_ImeFileName,
-       FreeRDP_DrivesToRedirect,
-       FreeRDP_RDP2TCPArgs,
+       FreeRDP_RemoteAssistancePassStub,
+       FreeRDP_RemoteAssistancePassword,
+       FreeRDP_RemoteAssistanceRCTicket,
+       FreeRDP_RemoteAssistanceSessionId,
+       FreeRDP_ServerHostname,
+       FreeRDP_ShellWorkingDirectory,
+       FreeRDP_TargetNetAddress,
+       FreeRDP_Username,
+       FreeRDP_WindowTitle,
+       FreeRDP_WmClass,
 };
 
 #define have_pointer_list_indices
 static const size_t pointer_list_indices[] = {
-       FreeRDP_StaticChannelArray,
-       FreeRDP_DynamicChannelArray,
-       FreeRDP_instance,
-       FreeRDP_RdpServerCertificate,
-       FreeRDP_MonitorIds,
-       FreeRDP_TargetNetPorts,
-       FreeRDP_DeviceArray,
-       FreeRDP_ClientAutoReconnectCookie,
-       FreeRDP_TargetNetAddresses,
-       FreeRDP_MonitorDefArray,
        FreeRDP_BitmapCacheV2CellInfo,
-       FreeRDP_ServerAutoReconnectCookie,
-       FreeRDP_ServerRandom,
-       FreeRDP_ServerCertificate,
+       FreeRDP_ChannelDefArray,
+       FreeRDP_ClientAutoReconnectCookie,
        FreeRDP_ClientRandom,
+       FreeRDP_ClientTimeZone,
+       FreeRDP_DeviceArray,
+       FreeRDP_DynamicChannelArray,
+       FreeRDP_FragCache,
+       FreeRDP_GlyphCache,
        FreeRDP_LoadBalanceInfo,
-       FreeRDP_RedirectionPassword,
-       FreeRDP_RedirectionTsvUrl,
-       FreeRDP_Password51,
-       FreeRDP_ReceivedCapabilities,
+       FreeRDP_MonitorDefArray,
+       FreeRDP_MonitorIds,
        FreeRDP_OrderSupport,
+       FreeRDP_Password51,
+       FreeRDP_RdpServerCertificate,
        FreeRDP_RdpServerRsaKey,
-       FreeRDP_GlyphCache,
-       FreeRDP_FragCache,
-       FreeRDP_ClientTimeZone,
-       FreeRDP_ChannelDefArray,
+       FreeRDP_ReceivedCapabilities,
+       FreeRDP_RedirectionPassword,
+       FreeRDP_RedirectionTsvUrl,
+       FreeRDP_ServerAutoReconnectCookie,
+       FreeRDP_ServerCertificate,
+       FreeRDP_ServerRandom,
+       FreeRDP_StaticChannelArray,
+       FreeRDP_TargetNetAddresses,
+       FreeRDP_TargetNetPorts,
+       FreeRDP_instance,
 };
 
 #endif /* TEST_SETTINGS_PROPERTY_LISTS */

diff --git a/scripts/update-settings-tests b/scripts/update-settings-tests
index 79368dc..25f1571 100755 (executable)
--- a/scripts/update-settings-tests
+++ b/scripts/update-settings-tests
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 import os
 import sys
 
@@ -12,6 +12,8 @@ def get_values(entry_dict, entry_type):
     elif entry_type in dict(entry_dict):
         values = entry_dict[entry_type]
         entry_dict.pop(entry_type, None)
+    if values:
+        return sorted(values)
     return values
 
 def write_entry(f, entry_dict, entry_type, entry_name):
@@ -28,6 +30,74 @@ def write_entry(f, entry_dict, entry_type, entry_name):
 
     f.write('};\n\n')
 
+def write_str_case(f, entry_type, val):
+    f.write('\t\t{FreeRDP_' + val + ', ' + str(entry_type) + ', "FreeRDP_' + val + '"},\n')
+
+def write_str(f, entry_dict):
+    f.write('struct settings_str_entry {\n')
+    f.write('\tsize_t id;\n')
+    f.write('\tsize_t type;\n')
+    f.write('\tconst char* str;\n')
+    f.write('};\n')
+    f.write('static const struct settings_str_entry settings_map[] =\n')
+    f.write('{\n')
+
+    entry_types = ['BOOL', 'UINT16', 'INT16', 'UINT32', 'INT32', 'UINT64', 'INT64', 'char*', '*']
+    for entry_type in entry_types:
+        values = get_values(entry_dict, entry_type)
+        if values:
+            for val in values:
+                write_str_case(f, entry_types.index(entry_type), val)
+    f.write('};\n\n')
+    f.write('SSIZE_T freerdp_settings_get_key_for_name(const char* value)\n')
+    f.write('{\n')
+    f.write('\tsize_t x;\n')
+    f.write('\tfor(x=0; x<ARRAYSIZE(settings_map); x++)\n')
+    f.write('\t{\n')
+    f.write('\t\tconst struct settings_str_entry* cur = &settings_map[x];\n')
+    f.write('\t\tif (strcmp(value, cur->str) == 0)\n')
+    f.write('\t\t\treturn cur->id;\n')
+    f.write('\t}\n')
+    f.write('\treturn -1;\n')
+    f.write('}\n')
+    f.write('\n')
+    f.write('SSIZE_T freerdp_settings_get_type_for_name(const char* value)\n')
+    f.write('{\n')
+    f.write('\tsize_t x;\n')
+    f.write('\tfor(x=0; x<ARRAYSIZE(settings_map); x++)\n')
+    f.write('\t{\n')
+    f.write('\t\tconst struct settings_str_entry* cur = &settings_map[x];\n')
+    f.write('\t\tif (strcmp(value, cur->str) == 0)\n')
+    f.write('\t\t\treturn cur->type;\n')
+    f.write('\t}\n')
+    f.write('\treturn -1;\n')
+    f.write('}\n')
+    f.write('\n')
+    f.write('SSIZE_T freerdp_settings_get_type_for_key(size_t key)\n')
+    f.write('{\n')
+    f.write('\tsize_t x;\n')
+    f.write('\tfor(x=0; x<ARRAYSIZE(settings_map); x++)\n')
+    f.write('\t{\n')
+    f.write('\t\tconst struct settings_str_entry* cur = &settings_map[x];\n')
+    f.write('\t\tif (cur->id == key)\n')
+    f.write('\t\t\treturn cur->type;\n')
+    f.write('\t}\n')
+    f.write('\treturn -1;\n')
+    f.write('}\n')
+    f.write('\n')
+    f.write('const char* freerdp_settings_get_name_for_key(size_t key)\n')
+    f.write('{\n')
+    f.write('\tsize_t x;\n')
+    f.write('\tfor(x=0; x<ARRAYSIZE(settings_map); x++)\n')
+    f.write('\t{\n')
+    f.write('\t\tconst struct settings_str_entry* cur = &settings_map[x];\n')
+    f.write('\t\tif (cur->id == key)\n')
+    f.write('\t\t\treturn cur->str;\n')
+    f.write('\t}\n')
+    f.write('\treturn NULL;\n')
+    f.write('}\n')
+    f.write('\n')
+
 def write_getter_case(f, val):
     f.write('\t\tcase FreeRDP_' + val + ':\n')
     f.write('\t\t\treturn settings->' + val + ';\n\n')
@@ -164,6 +234,17 @@ try:
 
         f.write('\n')
 
+    with open(name + '/../libfreerdp/common/settings_str.c', 'w+') as f:
+        f.write('/* Generated by ' + ''  + ' */\n\n')
+        f.write('#include <freerdp/settings.h>\n')
+        f.write('#include <freerdp/log.h>\n\n')
+        f.write('#define TAG FREERDP_TAG("common.settings")\n\n')
+
+        getter_list = dict(type_list)
+        write_str(f, getter_list)
+        f.write('\n')
+
+
     with open(name + '/../libfreerdp/core/test/settings_property_lists.h', 'w+') as f:
         f.write('#ifndef TEST_SETTINGS_PROPERTY_LISTS\n')
         f.write('#define TEST_SETTINGS_PROPERTY_LISTS\n\n')