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

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

1 files changed, 2707 insertions, 0 deletions

diff --git a/client/common/file.c b/client/common/file.c
new file mode 100644
index 0000000..760c62e
--- /dev/null
+++ b/client/common/file.c
@@ -0,0 +1,2707 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * .rdp file
+ *
+ * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <freerdp/config.h>
+
+#include <errno.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+#include <winpr/string.h>
+#include <winpr/file.h>
+
+#include <freerdp/client.h>
+#include <freerdp/client/file.h>
+#include <freerdp/client/cmdline.h>
+
+#include <freerdp/channels/urbdrc.h>
+#include <freerdp/channels/rdpecam.h>
+#include <freerdp/channels/location.h>
+
+/**
+ * Remote Desktop Plus - Overview of .rdp file settings:
+ * http://www.donkz.nl/files/rdpsettings.html
+ *
+ * RDP Settings for Remote Desktop Services in Windows Server 2008 R2:
+ * http://technet.microsoft.com/en-us/library/ff393699/
+ *
+ * https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/rdp-files
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <winpr/wtypes.h>
+#include <winpr/crt.h>
+#include <winpr/path.h>
+#include <freerdp/log.h>
+#define TAG CLIENT_TAG("common")
+
+/*#define DEBUG_CLIENT_FILE	1*/
+
+static const BYTE BOM_UTF16_LE[2] = { 0xFF, 0xFE };
+
+#define INVALID_INTEGER_VALUE 0xFFFFFFFF
+
+#define RDP_FILE_LINE_FLAG_FORMATTED 0x00000001
+#define RDP_FILE_LINE_FLAG_STANDARD 0x00000002
+#define RDP_FILE_LINE_FLAG_TYPE_STRING 0x00000010
+#define RDP_FILE_LINE_FLAG_TYPE_INTEGER 0x00000020
+#define RDP_FILE_LINE_FLAG_TYPE_BINARY 0x00000040
+
+struct rdp_file_line
+{
+	char* name;
+	LPSTR sValue;
+	PBYTE bValue;
+
+	size_t index;
+
+	long iValue;
+	DWORD flags;
+	int valueLength;
+};
+typedef struct rdp_file_line rdpFileLine;
+
+struct rdp_file
+{
+	DWORD UseMultiMon;                 /* use multimon */
+	LPSTR SelectedMonitors;            /* selectedmonitors */
+	DWORD MaximizeToCurrentDisplays;   /* maximizetocurrentdisplays */
+	DWORD SingleMonInWindowedMode;     /* singlemoninwindowedmode */
+	DWORD ScreenModeId;                /* screen mode id */
+	DWORD SpanMonitors;                /* span monitors */
+	DWORD SmartSizing;                 /* smartsizing */
+	DWORD DynamicResolution;           /* dynamic resolution */
+	DWORD EnableSuperSpan;             /* enablesuperpan */
+	DWORD SuperSpanAccelerationFactor; /* superpanaccelerationfactor */
+
+	DWORD DesktopWidth;       /* desktopwidth */
+	DWORD DesktopHeight;      /* desktopheight */
+	DWORD DesktopSizeId;      /* desktop size id */
+	DWORD SessionBpp;         /* session bpp */
+	DWORD DesktopScaleFactor; /* desktopscalefactor */
+
+	DWORD Compression;       /* compression */
+	DWORD KeyboardHook;      /* keyboardhook */
+	DWORD DisableCtrlAltDel; /* disable ctrl+alt+del */
+
+	DWORD AudioMode;                             /* audiomode */
+	DWORD AudioQualityMode;                      /* audioqualitymode */
+	DWORD AudioCaptureMode;                      /* audiocapturemode */
+	DWORD EncodeRedirectedVideoCapture;          /* encode redirected video capture */
+	DWORD RedirectedVideoCaptureEncodingQuality; /* redirected video capture encoding quality */
+	DWORD VideoPlaybackMode;                     /* videoplaybackmode */
+
+	DWORD ConnectionType; /* connection type */
+
+	DWORD NetworkAutoDetect;   /* networkautodetect */
+	DWORD BandwidthAutoDetect; /* bandwidthautodetect */
+
+	DWORD PinConnectionBar;     /* pinconnectionbar */
+	DWORD DisplayConnectionBar; /* displayconnectionbar */
+
+	DWORD WorkspaceId;              /* workspaceid */
+	DWORD EnableWorkspaceReconnect; /* enableworkspacereconnect */
+
+	DWORD DisableWallpaper;        /* disable wallpaper */
+	DWORD AllowFontSmoothing;      /* allow font smoothing */
+	DWORD AllowDesktopComposition; /* allow desktop composition */
+	DWORD DisableFullWindowDrag;   /* disable full window drag */
+	DWORD DisableMenuAnims;        /* disable menu anims */
+	DWORD DisableThemes;           /* disable themes */
+	DWORD DisableCursorSetting;    /* disable cursor setting */
+
+	DWORD BitmapCacheSize;          /* bitmapcachesize */
+	DWORD BitmapCachePersistEnable; /* bitmapcachepersistenable */
+
+	DWORD ServerPort; /* server port */
+
+	LPSTR Username;   /* username */
+	LPSTR Domain;     /* domain */
+	LPSTR Password;   /*password*/
+	PBYTE Password51; /* password 51 */
+
+	LPSTR FullAddress;          /* full address */
+	LPSTR AlternateFullAddress; /* alternate full address */
+
+	LPSTR UsbDevicesToRedirect;        /* usbdevicestoredirect */
+	DWORD RedirectDrives;              /* redirectdrives */
+	DWORD RedirectPrinters;            /* redirectprinters */
+	DWORD RedirectComPorts;            /* redirectcomports */
+	DWORD RedirectLocation;            /* redirectlocation */
+	DWORD RedirectSmartCards;          /* redirectsmartcards */
+	DWORD RedirectWebauthN;            /* redirectwebauthn */
+	LPSTR RedirectCameras;             /* camerastoredirect */
+	DWORD RedirectClipboard;           /* redirectclipboard */
+	DWORD RedirectPosDevices;          /* redirectposdevices */
+	DWORD RedirectDirectX;             /* redirectdirectx */
+	DWORD DisablePrinterRedirection;   /* disableprinterredirection */
+	DWORD DisableClipboardRedirection; /* disableclipboardredirection */
+
+	DWORD ConnectToConsole;        /* connect to console */
+	DWORD AdministrativeSession;   /* administrative session */
+	DWORD AutoReconnectionEnabled; /* autoreconnection enabled */
+	DWORD AutoReconnectMaxRetries; /* autoreconnect max retries */
+
+	DWORD PublicMode;             /* public mode */
+	DWORD AuthenticationLevel;    /* authentication level */
+	DWORD PromptCredentialOnce;   /* promptcredentialonce */
+	DWORD PromptForCredentials;   /* prompt for credentials */
+	DWORD NegotiateSecurityLayer; /* negotiate security layer */
+	DWORD EnableCredSSPSupport;   /* enablecredsspsupport */
+	DWORD EnableRdsAadAuth;       /* enablerdsaadauth */
+
+	DWORD RemoteApplicationMode; /* remoteapplicationmode */
+	LPSTR LoadBalanceInfo;       /* loadbalanceinfo */
+
+	LPSTR RemoteApplicationName;             /* remoteapplicationname */
+	LPSTR RemoteApplicationIcon;             /* remoteapplicationicon */
+	LPSTR RemoteApplicationProgram;          /* remoteapplicationprogram */
+	LPSTR RemoteApplicationFile;             /* remoteapplicationfile */
+	LPSTR RemoteApplicationGuid;             /* remoteapplicationguid */
+	LPSTR RemoteApplicationCmdLine;          /* remoteapplicationcmdline */
+	DWORD RemoteApplicationExpandCmdLine;    /* remoteapplicationexpandcmdline */
+	DWORD RemoteApplicationExpandWorkingDir; /* remoteapplicationexpandworkingdir */
+	DWORD DisableConnectionSharing;          /* disableconnectionsharing */
+	DWORD DisableRemoteAppCapsCheck;         /* disableremoteappcapscheck */
+
+	LPSTR AlternateShell;        /* alternate shell */
+	LPSTR ShellWorkingDirectory; /* shell working directory */
+
+	LPSTR GatewayHostname;           /* gatewayhostname */
+	DWORD GatewayUsageMethod;        /* gatewayusagemethod */
+	DWORD GatewayProfileUsageMethod; /* gatewayprofileusagemethod */
+	DWORD GatewayCredentialsSource;  /* gatewaycredentialssource */
+
+	LPSTR ResourceProvider; /* resourceprovider */
+
+	LPSTR WvdEndpointPool;      /* wvd endpoint pool */
+	LPSTR geo;                  /* geo */
+	LPSTR armpath;              /* armpath */
+	LPSTR aadtenantid;          /* aadtenantid" */
+	LPSTR diagnosticserviceurl; /* diagnosticserviceurl */
+	LPSTR hubdiscoverygeourl;   /* hubdiscoverygeourl" */
+	LPSTR activityhint;         /* activityhint */
+
+	DWORD UseRedirectionServerName; /* use redirection server name */
+
+	LPSTR GatewayAccessToken; /* gatewayaccesstoken */
+
+	LPSTR DrivesToRedirect;  /* drivestoredirect */
+	LPSTR DevicesToRedirect; /* devicestoredirect */
+	LPSTR WinPosStr;         /* winposstr */
+
+	LPSTR PreconnectionBlob; /* pcb */
+
+	LPSTR KdcProxyName;  /* kdcproxyname */
+	DWORD RdgIsKdcProxy; /* rdgiskdcproxy */
+
+	DWORD align1;
+
+	size_t lineCount;
+	size_t lineSize;
+	rdpFileLine* lines;
+
+	ADDIN_ARGV* args;
+	void* context;
+
+	DWORD flags;
+};
+
+static const char key_str_username[] = "username";
+static const char key_str_domain[] = "domain";
+static const char key_str_password[] = "password";
+static const char key_str_full_address[] = "full address";
+static const char key_str_alternate_full_address[] = "alternate full address";
+static const char key_str_usbdevicestoredirect[] = "usbdevicestoredirect";
+static const char key_str_camerastoredirect[] = "camerastoredirect";
+static const char key_str_loadbalanceinfo[] = "loadbalanceinfo";
+static const char key_str_remoteapplicationname[] = "remoteapplicationname";
+static const char key_str_remoteapplicationicon[] = "remoteapplicationicon";
+static const char key_str_remoteapplicationprogram[] = "remoteapplicationprogram";
+static const char key_str_remoteapplicationfile[] = "remoteapplicationfile";
+static const char key_str_remoteapplicationguid[] = "remoteapplicationguid";
+static const char key_str_remoteapplicationcmdline[] = "remoteapplicationcmdline";
+static const char key_str_alternate_shell[] = "alternate shell";
+static const char key_str_shell_working_directory[] = "shell working directory";
+static const char key_str_gatewayhostname[] = "gatewayhostname";
+static const char key_str_gatewayaccesstoken[] = "gatewayaccesstoken";
+static const char key_str_resourceprovider[] = "resourceprovider";
+static const char str_resourceprovider_arm[] = "arm";
+static const char key_str_kdcproxyname[] = "kdcproxyname";
+static const char key_str_drivestoredirect[] = "drivestoredirect";
+static const char key_str_devicestoredirect[] = "devicestoredirect";
+static const char key_str_winposstr[] = "winposstr";
+static const char key_str_pcb[] = "pcb";
+static const char key_str_selectedmonitors[] = "selectedmonitors";
+
+static const char key_str_wvd[] = "wvd endpoint pool";
+static const char key_str_geo[] = "geo";
+static const char key_str_armpath[] = "armpath";
+static const char key_str_aadtenantid[] = "aadtenantid";
+
+static const char key_str_diagnosticserviceurl[] = "diagnosticserviceurl";
+static const char key_str_hubdiscoverygeourl[] = "hubdiscoverygeourl";
+
+static const char key_str_activityhint[] = "activityhint";
+
+static const char key_int_rdgiskdcproxy[] = "rdgiskdcproxy";
+static const char key_int_use_redirection_server_name[] = "use redirection server name";
+static const char key_int_gatewaycredentialssource[] = "gatewaycredentialssource";
+static const char key_int_gatewayprofileusagemethod[] = "gatewayprofileusagemethod";
+static const char key_int_gatewayusagemethod[] = "gatewayusagemethod";
+static const char key_int_disableremoteappcapscheck[] = "disableremoteappcapscheck";
+static const char key_int_disableconnectionsharing[] = "disableconnectionsharing";
+static const char key_int_remoteapplicationexpandworkingdir[] = "remoteapplicationexpandworkingdir";
+static const char key_int_remoteapplicationexpandcmdline[] = "remoteapplicationexpandcmdline";
+static const char key_int_remoteapplicationmode[] = "remoteapplicationmode";
+static const char key_int_enablecredsspsupport[] = "enablecredsspsupport";
+static const char key_int_enablerdsaadauth[] = "enablerdsaadauth";
+static const char key_int_negotiate_security_layer[] = "negotiate security layer";
+static const char key_int_prompt_for_credentials[] = "prompt for credentials";
+static const char key_int_promptcredentialonce[] = "promptcredentialonce";
+static const char key_int_authentication_level[] = "authentication level";
+static const char key_int_public_mode[] = "public mode";
+static const char key_int_autoreconnect_max_retries[] = "autoreconnect max retries";
+static const char key_int_autoreconnection_enabled[] = "autoreconnection enabled";
+static const char key_int_administrative_session[] = "administrative session";
+static const char key_int_connect_to_console[] = "connect to console";
+static const char key_int_disableclipboardredirection[] = "disableclipboardredirection";
+static const char key_int_disableprinterredirection[] = "disableprinterredirection";
+static const char key_int_redirectdirectx[] = "redirectdirectx";
+static const char key_int_redirectposdevices[] = "redirectposdevices";
+static const char key_int_redirectclipboard[] = "redirectclipboard";
+static const char key_int_redirectsmartcards[] = "redirectsmartcards";
+static const char key_int_redirectcomports[] = "redirectcomports";
+static const char key_int_redirectlocation[] = "redirectlocation";
+static const char key_int_redirectprinters[] = "redirectprinters";
+static const char key_int_redirectdrives[] = "redirectdrives";
+static const char key_int_server_port[] = "server port";
+static const char key_int_bitmapcachepersistenable[] = "bitmapcachepersistenable";
+static const char key_int_bitmapcachesize[] = "bitmapcachesize";
+static const char key_int_disable_cursor_setting[] = "disable cursor setting";
+static const char key_int_disable_themes[] = "disable themes";
+static const char key_int_disable_menu_anims[] = "disable menu anims";
+static const char key_int_disable_full_window_drag[] = "disable full window drag";
+static const char key_int_allow_desktop_composition[] = "allow desktop composition";
+static const char key_int_allow_font_smoothing[] = "allow font smoothing";
+static const char key_int_disable_wallpaper[] = "disable wallpaper";
+static const char key_int_enableworkspacereconnect[] = "enableworkspacereconnect";
+static const char key_int_workspaceid[] = "workspaceid";
+static const char key_int_displayconnectionbar[] = "displayconnectionbar";
+static const char key_int_pinconnectionbar[] = "pinconnectionbar";
+static const char key_int_bandwidthautodetect[] = "bandwidthautodetect";
+static const char key_int_networkautodetect[] = "networkautodetect";
+static const char key_int_connection_type[] = "connection type";
+static const char key_int_videoplaybackmode[] = "videoplaybackmode";
+static const char key_int_redirected_video_capture_encoding_quality[] =
+    "redirected video capture encoding quality";
+static const char key_int_encode_redirected_video_capture[] = "encode redirected video capture";
+static const char key_int_audiocapturemode[] = "audiocapturemode";
+static const char key_int_audioqualitymode[] = "audioqualitymode";
+static const char key_int_audiomode[] = "audiomode";
+static const char key_int_disable_ctrl_alt_del[] = "disable ctrl+alt+del";
+static const char key_int_keyboardhook[] = "keyboardhook";
+static const char key_int_compression[] = "compression";
+static const char key_int_desktopscalefactor[] = "desktopscalefactor";
+static const char key_int_session_bpp[] = "session bpp";
+static const char key_int_desktop_size_id[] = "desktop size id";
+static const char key_int_desktopheight[] = "desktopheight";
+static const char key_int_desktopwidth[] = "desktopwidth";
+static const char key_int_superpanaccelerationfactor[] = "superpanaccelerationfactor";
+static const char key_int_enablesuperpan[] = "enablesuperpan";
+static const char key_int_dynamic_resolution[] = "dynamic resolution";
+static const char key_int_smart_sizing[] = "smart sizing";
+static const char key_int_span_monitors[] = "span monitors";
+static const char key_int_screen_mode_id[] = "screen mode id";
+static const char key_int_singlemoninwindowedmode[] = "singlemoninwindowedmode";
+static const char key_int_maximizetocurrentdisplays[] = "maximizetocurrentdisplays";
+static const char key_int_use_multimon[] = "use multimon";
+static const char key_int_redirectwebauthn[] = "redirectwebauthn";
+
+static SSIZE_T freerdp_client_rdp_file_add_line(rdpFile* file);
+static rdpFileLine* freerdp_client_rdp_file_find_line_by_name(const rdpFile* file,
+                                                              const char* name);
+static void freerdp_client_file_string_check_free(LPSTR str);
+
+static BOOL freerdp_client_rdp_file_find_integer_entry(rdpFile* file, const char* name,
+                                                       DWORD** outValue, rdpFileLine** outLine)
+{
+	WINPR_ASSERT(file);
+	WINPR_ASSERT(name);
+	WINPR_ASSERT(outValue);
+	WINPR_ASSERT(outLine);
+
+	*outValue = NULL;
+	*outLine = NULL;
+
+	if (_stricmp(name, key_int_use_multimon) == 0)
+		*outValue = &file->UseMultiMon;
+	else if (_stricmp(name, key_int_maximizetocurrentdisplays) == 0)
+		*outValue = &file->MaximizeToCurrentDisplays;
+	else if (_stricmp(name, key_int_singlemoninwindowedmode) == 0)
+		*outValue = &file->SingleMonInWindowedMode;
+	else if (_stricmp(name, key_int_screen_mode_id) == 0)
+		*outValue = &file->ScreenModeId;
+	else if (_stricmp(name, key_int_span_monitors) == 0)
+		*outValue = &file->SpanMonitors;
+	else if (_stricmp(name, key_int_smart_sizing) == 0)
+		*outValue = &file->SmartSizing;
+	else if (_stricmp(name, key_int_dynamic_resolution) == 0)
+		*outValue = &file->DynamicResolution;
+	else if (_stricmp(name, key_int_enablesuperpan) == 0)
+		*outValue = &file->EnableSuperSpan;
+	else if (_stricmp(name, key_int_superpanaccelerationfactor) == 0)
+		*outValue = &file->SuperSpanAccelerationFactor;
+	else if (_stricmp(name, key_int_desktopwidth) == 0)
+		*outValue = &file->DesktopWidth;
+	else if (_stricmp(name, key_int_desktopheight) == 0)
+		*outValue = &file->DesktopHeight;
+	else if (_stricmp(name, key_int_desktop_size_id) == 0)
+		*outValue = &file->DesktopSizeId;
+	else if (_stricmp(name, key_int_session_bpp) == 0)
+		*outValue = &file->SessionBpp;
+	else if (_stricmp(name, key_int_desktopscalefactor) == 0)
+		*outValue = &file->DesktopScaleFactor;
+	else if (_stricmp(name, key_int_compression) == 0)
+		*outValue = &file->Compression;
+	else if (_stricmp(name, key_int_keyboardhook) == 0)
+		*outValue = &file->KeyboardHook;
+	else if (_stricmp(name, key_int_disable_ctrl_alt_del) == 0)
+		*outValue = &file->DisableCtrlAltDel;
+	else if (_stricmp(name, key_int_audiomode) == 0)
+		*outValue = &file->AudioMode;
+	else if (_stricmp(name, key_int_audioqualitymode) == 0)
+		*outValue = &file->AudioQualityMode;
+	else if (_stricmp(name, key_int_audiocapturemode) == 0)
+		*outValue = &file->AudioCaptureMode;
+	else if (_stricmp(name, key_int_encode_redirected_video_capture) == 0)
+		*outValue = &file->EncodeRedirectedVideoCapture;
+	else if (_stricmp(name, key_int_redirected_video_capture_encoding_quality) == 0)
+		*outValue = &file->RedirectedVideoCaptureEncodingQuality;
+	else if (_stricmp(name, key_int_videoplaybackmode) == 0)
+		*outValue = &file->VideoPlaybackMode;
+	else if (_stricmp(name, key_int_connection_type) == 0)
+		*outValue = &file->ConnectionType;
+	else if (_stricmp(name, key_int_networkautodetect) == 0)
+		*outValue = &file->NetworkAutoDetect;
+	else if (_stricmp(name, key_int_bandwidthautodetect) == 0)
+		*outValue = &file->BandwidthAutoDetect;
+	else if (_stricmp(name, key_int_pinconnectionbar) == 0)
+		*outValue = &file->PinConnectionBar;
+	else if (_stricmp(name, key_int_displayconnectionbar) == 0)
+		*outValue = &file->DisplayConnectionBar;
+	else if (_stricmp(name, key_int_workspaceid) == 0)
+		*outValue = &file->WorkspaceId;
+	else if (_stricmp(name, key_int_enableworkspacereconnect) == 0)
+		*outValue = &file->EnableWorkspaceReconnect;
+	else if (_stricmp(name, key_int_disable_wallpaper) == 0)
+		*outValue = &file->DisableWallpaper;
+	else if (_stricmp(name, key_int_allow_font_smoothing) == 0)
+		*outValue = &file->AllowFontSmoothing;
+	else if (_stricmp(name, key_int_allow_desktop_composition) == 0)
+		*outValue = &file->AllowDesktopComposition;
+	else if (_stricmp(name, key_int_disable_full_window_drag) == 0)
+		*outValue = &file->DisableFullWindowDrag;
+	else if (_stricmp(name, key_int_disable_menu_anims) == 0)
+		*outValue = &file->DisableMenuAnims;
+	else if (_stricmp(name, key_int_disable_themes) == 0)
+		*outValue = &file->DisableThemes;
+	else if (_stricmp(name, key_int_disable_cursor_setting) == 0)
+		*outValue = &file->DisableCursorSetting;
+	else if (_stricmp(name, key_int_bitmapcachesize) == 0)
+		*outValue = &file->BitmapCacheSize;
+	else if (_stricmp(name, key_int_bitmapcachepersistenable) == 0)
+		*outValue = &file->BitmapCachePersistEnable;
+	else if (_stricmp(name, key_int_server_port) == 0)
+		*outValue = &file->ServerPort;
+	else if (_stricmp(name, key_int_redirectdrives) == 0)
+		*outValue = &file->RedirectDrives;
+	else if (_stricmp(name, key_int_redirectprinters) == 0)
+		*outValue = &file->RedirectPrinters;
+	else if (_stricmp(name, key_int_redirectcomports) == 0)
+		*outValue = &file->RedirectComPorts;
+	else if (_stricmp(name, key_int_redirectlocation) == 0)
+		*outValue = &file->RedirectLocation;
+	else if (_stricmp(name, key_int_redirectsmartcards) == 0)
+		*outValue = &file->RedirectSmartCards;
+	else if (_stricmp(name, key_int_redirectclipboard) == 0)
+		*outValue = &file->RedirectClipboard;
+	else if (_stricmp(name, key_int_redirectposdevices) == 0)
+		*outValue = &file->RedirectPosDevices;
+	else if (_stricmp(name, key_int_redirectdirectx) == 0)
+		*outValue = &file->RedirectDirectX;
+	else if (_stricmp(name, key_int_disableprinterredirection) == 0)
+		*outValue = &file->DisablePrinterRedirection;
+	else if (_stricmp(name, key_int_disableclipboardredirection) == 0)
+		*outValue = &file->DisableClipboardRedirection;
+	else if (_stricmp(name, key_int_connect_to_console) == 0)
+		*outValue = &file->ConnectToConsole;
+	else if (_stricmp(name, key_int_administrative_session) == 0)
+		*outValue = &file->AdministrativeSession;
+	else if (_stricmp(name, key_int_autoreconnection_enabled) == 0)
+		*outValue = &file->AutoReconnectionEnabled;
+	else if (_stricmp(name, key_int_autoreconnect_max_retries) == 0)
+		*outValue = &file->AutoReconnectMaxRetries;
+	else if (_stricmp(name, key_int_public_mode) == 0)
+		*outValue = &file->PublicMode;
+	else if (_stricmp(name, key_int_authentication_level) == 0)
+		*outValue = &file->AuthenticationLevel;
+	else if (_stricmp(name, key_int_promptcredentialonce) == 0)
+		*outValue = &file->PromptCredentialOnce;
+	else if ((_stricmp(name, key_int_prompt_for_credentials) == 0))
+		*outValue = &file->PromptForCredentials;
+	else if (_stricmp(name, key_int_negotiate_security_layer) == 0)
+		*outValue = &file->NegotiateSecurityLayer;
+	else if (_stricmp(name, key_int_enablecredsspsupport) == 0)
+		*outValue = &file->EnableCredSSPSupport;
+	else if (_stricmp(name, key_int_enablerdsaadauth) == 0)
+		*outValue = &file->EnableRdsAadAuth;
+	else if (_stricmp(name, key_int_remoteapplicationmode) == 0)
+		*outValue = &file->RemoteApplicationMode;
+	else if (_stricmp(name, key_int_remoteapplicationexpandcmdline) == 0)
+		*outValue = &file->RemoteApplicationExpandCmdLine;
+	else if (_stricmp(name, key_int_remoteapplicationexpandworkingdir) == 0)
+		*outValue = &file->RemoteApplicationExpandWorkingDir;
+	else if (_stricmp(name, key_int_disableconnectionsharing) == 0)
+		*outValue = &file->DisableConnectionSharing;
+	else if (_stricmp(name, key_int_disableremoteappcapscheck) == 0)
+		*outValue = &file->DisableRemoteAppCapsCheck;
+	else if (_stricmp(name, key_int_gatewayusagemethod) == 0)
+		*outValue = &file->GatewayUsageMethod;
+	else if (_stricmp(name, key_int_gatewayprofileusagemethod) == 0)
+		*outValue = &file->GatewayProfileUsageMethod;
+	else if (_stricmp(name, key_int_gatewaycredentialssource) == 0)
+		*outValue = &file->GatewayCredentialsSource;
+	else if (_stricmp(name, key_int_use_redirection_server_name) == 0)
+		*outValue = &file->UseRedirectionServerName;
+	else if (_stricmp(name, key_int_rdgiskdcproxy) == 0)
+		*outValue = &file->RdgIsKdcProxy;
+	else if (_stricmp(name, key_int_redirectwebauthn) == 0)
+		*outValue = &file->RedirectWebauthN;
+	else
+	{
+		rdpFileLine* line = freerdp_client_rdp_file_find_line_by_name(file, name);
+		if (!line)
+			return FALSE;
+		if (!(line->flags & RDP_FILE_LINE_FLAG_TYPE_INTEGER))
+			return FALSE;
+
+		*outLine = line;
+	}
+
+	return TRUE;
+}
+
+static BOOL freerdp_client_rdp_file_find_string_entry(rdpFile* file, const char* name,
+                                                      LPSTR** outValue, rdpFileLine** outLine)
+{
+	WINPR_ASSERT(file);
+	WINPR_ASSERT(name);
+	WINPR_ASSERT(outValue);
+	WINPR_ASSERT(outLine);
+
+	*outValue = NULL;
+	*outLine = NULL;
+
+	if (_stricmp(name, key_str_username) == 0)
+		*outValue = &file->Username;
+	else if (_stricmp(name, key_str_domain) == 0)
+		*outValue = &file->Domain;
+	else if (_stricmp(name, key_str_password) == 0)
+		*outValue = &file->Password;
+	else if (_stricmp(name, key_str_full_address) == 0)
+		*outValue = &file->FullAddress;
+	else if (_stricmp(name, key_str_alternate_full_address) == 0)
+		*outValue = &file->AlternateFullAddress;
+	else if (_stricmp(name, key_str_usbdevicestoredirect) == 0)
+		*outValue = &file->UsbDevicesToRedirect;
+	else if (_stricmp(name, key_str_camerastoredirect) == 0)
+		*outValue = &file->RedirectCameras;
+	else if (_stricmp(name, key_str_loadbalanceinfo) == 0)
+		*outValue = &file->LoadBalanceInfo;
+	else if (_stricmp(name, key_str_remoteapplicationname) == 0)
+		*outValue = &file->RemoteApplicationName;
+	else if (_stricmp(name, key_str_remoteapplicationicon) == 0)
+		*outValue = &file->RemoteApplicationIcon;
+	else if (_stricmp(name, key_str_remoteapplicationprogram) == 0)
+		*outValue = &file->RemoteApplicationProgram;
+	else if (_stricmp(name, key_str_remoteapplicationfile) == 0)
+		*outValue = &file->RemoteApplicationFile;
+	else if (_stricmp(name, key_str_remoteapplicationguid) == 0)
+		*outValue = &file->RemoteApplicationGuid;
+	else if (_stricmp(name, key_str_remoteapplicationcmdline) == 0)
+		*outValue = &file->RemoteApplicationCmdLine;
+	else if (_stricmp(name, key_str_alternate_shell) == 0)
+		*outValue = &file->AlternateShell;
+	else if (_stricmp(name, key_str_shell_working_directory) == 0)
+		*outValue = &file->ShellWorkingDirectory;
+	else if (_stricmp(name, key_str_gatewayhostname) == 0)
+		*outValue = &file->GatewayHostname;
+	else if (_stricmp(name, key_str_resourceprovider) == 0)
+		*outValue = &file->ResourceProvider;
+	else if (_stricmp(name, key_str_wvd) == 0)
+		*outValue = &file->WvdEndpointPool;
+	else if (_stricmp(name, key_str_geo) == 0)
+		*outValue = &file->geo;
+	else if (_stricmp(name, key_str_armpath) == 0)
+		*outValue = &file->armpath;
+	else if (_stricmp(name, key_str_aadtenantid) == 0)
+		*outValue = &file->aadtenantid;
+	else if (_stricmp(name, key_str_diagnosticserviceurl) == 0)
+		*outValue = &file->diagnosticserviceurl;
+	else if (_stricmp(name, key_str_hubdiscoverygeourl) == 0)
+		*outValue = &file->hubdiscoverygeourl;
+	else if (_stricmp(name, key_str_activityhint) == 0)
+		*outValue = &file->activityhint;
+	else if (_stricmp(name, key_str_gatewayaccesstoken) == 0)
+		*outValue = &file->GatewayAccessToken;
+	else if (_stricmp(name, key_str_kdcproxyname) == 0)
+		*outValue = &file->KdcProxyName;
+	else if (_stricmp(name, key_str_drivestoredirect) == 0)
+		*outValue = &file->DrivesToRedirect;
+	else if (_stricmp(name, key_str_devicestoredirect) == 0)
+		*outValue = &file->DevicesToRedirect;
+	else if (_stricmp(name, key_str_winposstr) == 0)
+		*outValue = &file->WinPosStr;
+	else if (_stricmp(name, key_str_pcb) == 0)
+		*outValue = &file->PreconnectionBlob;
+	else if (_stricmp(name, key_str_selectedmonitors) == 0)
+		*outValue = &file->SelectedMonitors;
+	else
+	{
+		rdpFileLine* line = freerdp_client_rdp_file_find_line_by_name(file, name);
+		if (!line)
+			return FALSE;
+		if (!(line->flags & RDP_FILE_LINE_FLAG_TYPE_STRING))
+			return FALSE;
+
+		*outLine = line;
+	}
+
+	return TRUE;
+}
+
+/*
+ * Set an integer in a rdpFile
+ *
+ * @return FALSE if a standard name was set, TRUE for a non-standard name, FALSE on error
+ *
+ */
+static BOOL freerdp_client_rdp_file_set_integer(rdpFile* file, const char* name, long value)
+{
+	DWORD* targetValue = NULL;
+	rdpFileLine* line = NULL;
+#ifdef DEBUG_CLIENT_FILE
+	WLog_DBG(TAG, "%s:i:%ld", name, value);
+#endif
+
+	if (value < 0)
+		return FALSE;
+
+	if (!freerdp_client_rdp_file_find_integer_entry(file, name, &targetValue, &line))
+	{
+		SSIZE_T index = freerdp_client_rdp_file_add_line(file);
+		if (index == -1)
+			return FALSE;
+		line = &file->lines[index];
+	}
+
+	if (targetValue)
+	{
+		*targetValue = (DWORD)value;
+		return TRUE;
+	}
+
+	if (line)
+	{
+		free(line->name);
+		line->name = _strdup(name);
+		if (!line->name)
+		{
+			free(line->name);
+			line->name = NULL;
+			return FALSE;
+		}
+
+		line->iValue = value;
+		line->flags = RDP_FILE_LINE_FLAG_FORMATTED;
+		line->flags |= RDP_FILE_LINE_FLAG_TYPE_INTEGER;
+		line->valueLength = 0;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL freerdp_client_parse_rdp_file_integer(rdpFile* file, const char* name,
+                                                  const char* value)
+{
+	char* endptr = NULL;
+	long ivalue = 0;
+	errno = 0;
+	ivalue = strtol(value, &endptr, 0);
+
+	if ((endptr == NULL) || (errno != 0) || (endptr == value) || (ivalue > INT32_MAX) ||
+	    (ivalue < INT32_MIN))
+	{
+		if (file->flags & RDP_FILE_FLAG_PARSE_INT_RELAXED)
+		{
+			WLog_WARN(TAG, "Integer option %s has invalid value %s, using default", name, value);
+			return TRUE;
+		}
+		else
+		{
+			WLog_ERR(TAG, "Failed to convert RDP file integer option %s [value=%s]", name, value);
+			return FALSE;
+		}
+	}
+
+	return freerdp_client_rdp_file_set_integer(file, name, ivalue);
+}
+
+/** set a string value in the provided rdp file context
+ *
+ * @param file rdpFile
+ * @param name name of the string
+ * @param value value of the string to set
+ * @return 0 on success, 1 if the key wasn't found (not a standard key), -1 on error
+ */
+
+static BOOL freerdp_client_rdp_file_set_string(rdpFile* file, const char* name, const char* value)
+{
+	LPSTR* targetValue = NULL;
+	rdpFileLine* line = NULL;
+#ifdef DEBUG_CLIENT_FILE
+	WLog_DBG(TAG, "%s:s:%s", name, value);
+#endif
+
+	if (!name || !value)
+		return FALSE;
+
+	if (!freerdp_client_rdp_file_find_string_entry(file, name, &targetValue, &line))
+	{
+		SSIZE_T index = freerdp_client_rdp_file_add_line(file);
+		if (index == -1)
+			return FALSE;
+		line = &file->lines[index];
+	}
+
+	if (targetValue)
+	{
+		*targetValue = _strdup(value);
+		if (!(*targetValue))
+			return FALSE;
+		return TRUE;
+	}
+
+	if (line)
+	{
+		free(line->name);
+		free(line->sValue);
+		line->name = _strdup(name);
+		line->sValue = _strdup(value);
+		if (!line->name || !line->sValue)
+		{
+			free(line->name);
+			free(line->sValue);
+			line->name = NULL;
+			line->sValue = NULL;
+			return FALSE;
+		}
+
+		line->flags = RDP_FILE_LINE_FLAG_FORMATTED;
+		line->flags |= RDP_FILE_LINE_FLAG_TYPE_STRING;
+		line->valueLength = 0;
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static BOOL freerdp_client_add_option(rdpFile* file, const char* option)
+{
+	return freerdp_addin_argv_add_argument(file->args, option);
+}
+
+static SSIZE_T freerdp_client_rdp_file_add_line(rdpFile* file)
+{
+	SSIZE_T index = (SSIZE_T)file->lineCount;
+
+	while ((file->lineCount + 1) > file->lineSize)
+	{
+		size_t new_size = 0;
+		rdpFileLine* new_line = NULL;
+		new_size = file->lineSize * 2;
+		new_line = (rdpFileLine*)realloc(file->lines, new_size * sizeof(rdpFileLine));
+
+		if (!new_line)
+			return -1;
+
+		file->lines = new_line;
+		file->lineSize = new_size;
+	}
+
+	ZeroMemory(&(file->lines[file->lineCount]), sizeof(rdpFileLine));
+	file->lines[file->lineCount].index = (size_t)index;
+	(file->lineCount)++;
+	return index;
+}
+
+static BOOL freerdp_client_parse_rdp_file_string(rdpFile* file, char* name, char* value)
+{
+	return freerdp_client_rdp_file_set_string(file, name, value);
+}
+
+static BOOL freerdp_client_parse_rdp_file_option(rdpFile* file, const char* option)
+{
+	return freerdp_client_add_option(file, option);
+}
+
+BOOL freerdp_client_parse_rdp_file_buffer(rdpFile* file, const BYTE* buffer, size_t size)
+{
+	return freerdp_client_parse_rdp_file_buffer_ex(file, buffer, size, NULL);
+}
+
+static BOOL trim(char** strptr)
+{
+	char* start = NULL;
+	char* str = NULL;
+	char* end = NULL;
+
+	start = str = *strptr;
+	if (!str)
+		return TRUE;
+	if (!(~((size_t)str)))
+		return TRUE;
+	end = str + strlen(str) - 1;
+
+	while (isspace(*str))
+		str++;
+
+	while ((end > str) && isspace(*end))
+		end--;
+	end[1] = '\0';
+	if (start == str)
+		*strptr = str;
+	else
+	{
+		*strptr = _strdup(str);
+		free(start);
+		return *strptr != NULL;
+	}
+
+	return TRUE;
+}
+
+static BOOL trim_strings(rdpFile* file)
+{
+	if (!trim(&file->Username))
+		return FALSE;
+	if (!trim(&file->Domain))
+		return FALSE;
+	if (!trim(&file->AlternateFullAddress))
+		return FALSE;
+	if (!trim(&file->FullAddress))
+		return FALSE;
+	if (!trim(&file->UsbDevicesToRedirect))
+		return FALSE;
+	if (!trim(&file->RedirectCameras))
+		return FALSE;
+	if (!trim(&file->LoadBalanceInfo))
+		return FALSE;
+	if (!trim(&file->GatewayHostname))
+		return FALSE;
+	if (!trim(&file->GatewayAccessToken))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationName))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationIcon))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationProgram))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationFile))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationGuid))
+		return FALSE;
+	if (!trim(&file->RemoteApplicationCmdLine))
+		return FALSE;
+	if (!trim(&file->AlternateShell))
+		return FALSE;
+	if (!trim(&file->ShellWorkingDirectory))
+		return FALSE;
+	if (!trim(&file->DrivesToRedirect))
+		return FALSE;
+	if (!trim(&file->DevicesToRedirect))
+		return FALSE;
+	if (!trim(&file->DevicesToRedirect))
+		return FALSE;
+	if (!trim(&file->WinPosStr))
+		return FALSE;
+	if (!trim(&file->PreconnectionBlob))
+		return FALSE;
+	if (!trim(&file->KdcProxyName))
+		return FALSE;
+	if (!trim(&file->SelectedMonitors))
+		return FALSE;
+
+	for (size_t i = 0; i < file->lineCount; ++i)
+	{
+		rdpFileLine* curLine = &file->lines[i];
+		if (curLine->flags & RDP_FILE_LINE_FLAG_TYPE_STRING)
+		{
+			if (!trim(&curLine->sValue))
+				return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOL freerdp_client_parse_rdp_file_buffer_ex(rdpFile* file, const BYTE* buffer, size_t size,
+                                             rdp_file_fkt_parse parse)
+{
+	BOOL rc = FALSE;
+	size_t length = 0;
+	char* line = NULL;
+	char* type = NULL;
+	char* context = NULL;
+	char* d1 = NULL;
+	char* d2 = NULL;
+	char* beg = NULL;
+	char* name = NULL;
+	char* value = NULL;
+	char* copy = NULL;
+
+	if (!file)
+		return FALSE;
+	if (size < 2)
+		return FALSE;
+
+	if ((buffer[0] == BOM_UTF16_LE[0]) && (buffer[1] == BOM_UTF16_LE[1]))
+	{
+		LPCWSTR uc = (LPCWSTR)(&buffer[2]);
+		size = size / sizeof(WCHAR) - 1;
+
+		copy = ConvertWCharNToUtf8Alloc(uc, size, NULL);
+		if (!copy)
+		{
+			WLog_ERR(TAG, "Failed to convert RDP file from UCS2 to UTF8");
+			return FALSE;
+		}
+	}
+	else
+	{
+		copy = calloc(1, size + sizeof(BYTE));
+
+		if (!copy)
+			return FALSE;
+
+		memcpy(copy, buffer, size);
+	}
+
+	line = strtok_s(copy, "\r\n", &context);
+
+	while (line)
+	{
+		length = strnlen(line, size);
+
+		if (length > 1)
+		{
+			beg = line;
+			if (beg[0] == '/')
+			{
+				if (!freerdp_client_parse_rdp_file_option(file, line))
+					goto fail;
+
+				goto next_line; /* FreeRDP option */
+			}
+
+			d1 = strchr(line, ':');
+
+			if (!d1)
+				goto next_line; /* not first delimiter */
+
+			type = &d1[1];
+			d2 = strchr(type, ':');
+
+			if (!d2)
+				goto next_line; /* no second delimiter */
+
+			if ((d2 - d1) != 2)
+				goto next_line; /* improper type length */
+
+			*d1 = 0;
+			*d2 = 0;
+			name = beg;
+			value = &d2[1];
+
+			if (parse && parse(file->context, name, *type, value))
+			{
+			}
+			else if (*type == 'i')
+			{
+				/* integer type */
+				if (!freerdp_client_parse_rdp_file_integer(file, name, value))
+					goto fail;
+			}
+			else if (*type == 's')
+			{
+				/* string type */
+				if (!freerdp_client_parse_rdp_file_string(file, name, value))
+					goto fail;
+			}
+			else if (*type == 'b')
+			{
+				/* binary type */
+				WLog_ERR(TAG, "Unsupported RDP file binary option %s [value=%s]", name, value);
+			}
+		}
+
+	next_line:
+		line = strtok_s(NULL, "\r\n", &context);
+	}
+
+	rc = trim_strings(file);
+fail:
+	free(copy);
+	return rc;
+}
+
+BOOL freerdp_client_parse_rdp_file(rdpFile* file, const char* name)
+{
+	return freerdp_client_parse_rdp_file_ex(file, name, NULL);
+}
+
+BOOL freerdp_client_parse_rdp_file_ex(rdpFile* file, const char* name, rdp_file_fkt_parse parse)
+{
+	BOOL status = 0;
+	BYTE* buffer = NULL;
+	FILE* fp = NULL;
+	size_t read_size = 0;
+	INT64 file_size = 0;
+	const char* fname = name;
+
+	if (!file || !name)
+		return FALSE;
+
+	if (_strnicmp(fname, "file://", 7) == 0)
+		fname = &name[7];
+
+	fp = winpr_fopen(fname, "r");
+	if (!fp)
+	{
+		WLog_ERR(TAG, "Failed to open RDP file %s", name);
+		return FALSE;
+	}
+
+	_fseeki64(fp, 0, SEEK_END);
+	file_size = _ftelli64(fp);
+	_fseeki64(fp, 0, SEEK_SET);
+
+	if (file_size < 1)
+	{
+		WLog_ERR(TAG, "RDP file %s is empty", name);
+		fclose(fp);
+		return FALSE;
+	}
+
+	buffer = (BYTE*)malloc((size_t)file_size + 2);
+
+	if (!buffer)
+	{
+		fclose(fp);
+		return FALSE;
+	}
+
+	read_size = fread(buffer, (size_t)file_size, 1, fp);
+
+	if (!read_size)
+	{
+		if (!ferror(fp))
+			read_size = (size_t)file_size;
+	}
+
+	fclose(fp);
+
+	if (read_size < 1)
+	{
+		WLog_ERR(TAG, "Could not read from RDP file %s", name);
+		free(buffer);
+		return FALSE;
+	}
+
+	buffer[file_size] = '\0';
+	buffer[file_size + 1] = '\0';
+	status = freerdp_client_parse_rdp_file_buffer_ex(file, buffer, (size_t)file_size, parse);
+	free(buffer);
+	return status;
+}
+
+static INLINE BOOL FILE_POPULATE_STRING(char** _target, const rdpSettings* _settings,
+                                        FreeRDP_Settings_Keys_String _option)
+{
+	WINPR_ASSERT(_target);
+	WINPR_ASSERT(_settings);
+
+	const char* str = freerdp_settings_get_string(_settings, _option);
+	freerdp_client_file_string_check_free(*_target);
+	*_target = (void*)~((size_t)NULL);
+	if (str)
+	{
+		*_target = _strdup(str);
+		if (!_target)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static char* freerdp_client_channel_args_to_string(const rdpSettings* settings, const char* channel,
+                                                   const char* option)
+{
+	ADDIN_ARGV* args = freerdp_dynamic_channel_collection_find(settings, channel);
+	const char* filters[] = { option };
+	if (!args || (args->argc < 2))
+		return NULL;
+
+	return CommandLineToCommaSeparatedValuesEx(args->argc - 1, args->argv + 1, filters,
+	                                           ARRAYSIZE(filters));
+}
+
+static BOOL rdp_opt_duplicate(const rdpSettings* _settings, FreeRDP_Settings_Keys_String _id,
+                              char** _key)
+{
+	WINPR_ASSERT(_settings);
+	WINPR_ASSERT(_key);
+	const char* tmp = freerdp_settings_get_string(_settings, _id);
+
+	if (tmp)
+	{
+		*_key = _strdup(tmp);
+		if (!*_key)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+BOOL freerdp_client_populate_rdp_file_from_settings(rdpFile* file, const rdpSettings* settings)
+{
+	FreeRDP_Settings_Keys_String index = FreeRDP_STRING_UNUSED;
+	UINT32 LoadBalanceInfoLength = 0;
+	const char* GatewayHostname = NULL;
+	char* redirectCameras = NULL;
+	char* redirectUsb = NULL;
+
+	if (!file || !settings)
+		return FALSE;
+
+	if (!FILE_POPULATE_STRING(&file->Domain, settings, FreeRDP_Domain) ||
+	    !FILE_POPULATE_STRING(&file->Username, settings, FreeRDP_Username) ||
+	    !FILE_POPULATE_STRING(&file->Password, settings, FreeRDP_Password) ||
+	    !FILE_POPULATE_STRING(&file->FullAddress, settings, FreeRDP_ServerHostname) ||
+	    !FILE_POPULATE_STRING(&file->AlternateFullAddress, settings, FreeRDP_ServerHostname) ||
+	    !FILE_POPULATE_STRING(&file->AlternateShell, settings, FreeRDP_AlternateShell) ||
+	    !FILE_POPULATE_STRING(&file->DrivesToRedirect, settings, FreeRDP_DrivesToRedirect))
+
+		return FALSE;
+	file->ServerPort = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
+
+	file->DesktopWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	file->DesktopHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	file->SessionBpp = freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth);
+	file->DesktopScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+	file->DynamicResolution = freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate);
+	file->VideoPlaybackMode = freerdp_settings_get_bool(settings, FreeRDP_SupportVideoOptimized);
+
+	// TODO file->MaximizeToCurrentDisplays;
+	// TODO file->SingleMonInWindowedMode;
+	// TODO file->EncodeRedirectedVideoCapture;
+	// TODO file->RedirectedVideoCaptureEncodingQuality;
+	file->ConnectToConsole = freerdp_settings_get_bool(settings, FreeRDP_ConsoleSession);
+	file->NegotiateSecurityLayer =
+	    freerdp_settings_get_bool(settings, FreeRDP_NegotiateSecurityLayer);
+	file->EnableCredSSPSupport = freerdp_settings_get_bool(settings, FreeRDP_NlaSecurity);
+	file->EnableRdsAadAuth = freerdp_settings_get_bool(settings, FreeRDP_AadSecurity);
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode))
+		index = FreeRDP_RemoteApplicationWorkingDir;
+	else
+		index = FreeRDP_ShellWorkingDirectory;
+	if (!FILE_POPULATE_STRING(&file->ShellWorkingDirectory, settings, index))
+		return FALSE;
+	file->ConnectionType = freerdp_settings_get_uint32(settings, FreeRDP_ConnectionType);
+
+	file->ScreenModeId = freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) ? 2 : 1;
+
+	LoadBalanceInfoLength = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
+	if (LoadBalanceInfoLength > 0)
+	{
+		const BYTE* LoadBalanceInfo =
+		    freerdp_settings_get_pointer(settings, FreeRDP_LoadBalanceInfo);
+		file->LoadBalanceInfo = calloc(LoadBalanceInfoLength + 1, 1);
+		if (!file->LoadBalanceInfo)
+			return FALSE;
+		memcpy(file->LoadBalanceInfo, LoadBalanceInfo, LoadBalanceInfoLength);
+	}
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_AudioPlayback))
+		file->AudioMode = AUDIO_MODE_REDIRECT;
+	else if (freerdp_settings_get_bool(settings, FreeRDP_RemoteConsoleAudio))
+		file->AudioMode = AUDIO_MODE_PLAY_ON_SERVER;
+	else
+		file->AudioMode = AUDIO_MODE_NONE;
+
+	/* The gateway hostname should also contain a port specifier unless it is the default port 443
+	 */
+	GatewayHostname = freerdp_settings_get_string(settings, FreeRDP_GatewayHostname);
+	if (GatewayHostname)
+	{
+		const UINT32 GatewayPort = freerdp_settings_get_uint32(settings, FreeRDP_GatewayPort);
+		freerdp_client_file_string_check_free(file->GatewayHostname);
+		if (GatewayPort == 443)
+			file->GatewayHostname = _strdup(GatewayHostname);
+		else
+		{
+			int length = _scprintf("%s:%" PRIu32, GatewayHostname, GatewayPort);
+			if (length < 0)
+				return FALSE;
+
+			file->GatewayHostname = (char*)malloc((size_t)length + 1);
+			if (!file->GatewayHostname)
+				return FALSE;
+
+			if (sprintf_s(file->GatewayHostname, (size_t)length + 1, "%s:%" PRIu32, GatewayHostname,
+			              GatewayPort) < 0)
+				return FALSE;
+		}
+		if (!file->GatewayHostname)
+			return FALSE;
+	}
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_GatewayArmTransport))
+		file->ResourceProvider = _strdup(str_resourceprovider_arm);
+
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdWvdEndpointPool, &file->WvdEndpointPool))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdGeo, &file->geo))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdArmpath, &file->armpath))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdAadtenantid, &file->aadtenantid))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdDiagnosticserviceurl,
+	                       &file->diagnosticserviceurl))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdHubdiscoverygeourl,
+	                       &file->hubdiscoverygeourl))
+		return FALSE;
+	if (!rdp_opt_duplicate(settings, FreeRDP_GatewayAvdActivityhint, &file->activityhint))
+		return FALSE;
+
+	file->AudioCaptureMode = freerdp_settings_get_bool(settings, FreeRDP_AudioCapture);
+	file->BitmapCachePersistEnable =
+	    freerdp_settings_get_bool(settings, FreeRDP_BitmapCachePersistEnabled);
+	file->Compression = freerdp_settings_get_bool(settings, FreeRDP_CompressionEnabled);
+	file->AuthenticationLevel = freerdp_settings_get_uint32(settings, FreeRDP_AuthenticationLevel);
+	file->GatewayUsageMethod = freerdp_settings_get_uint32(settings, FreeRDP_GatewayUsageMethod);
+	file->GatewayCredentialsSource =
+	    freerdp_settings_get_uint32(settings, FreeRDP_GatewayCredentialsSource);
+	file->PromptCredentialOnce =
+	    freerdp_settings_get_bool(settings, FreeRDP_GatewayUseSameCredentials);
+	file->PromptForCredentials = freerdp_settings_get_bool(settings, FreeRDP_PromptForCredentials);
+	file->RemoteApplicationMode =
+	    freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode);
+	if (!FILE_POPULATE_STRING(&file->GatewayAccessToken, settings, FreeRDP_GatewayAccessToken) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationProgram, settings,
+	                          FreeRDP_RemoteApplicationProgram) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationName, settings,
+	                          FreeRDP_RemoteApplicationName) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationIcon, settings,
+	                          FreeRDP_RemoteApplicationIcon) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationFile, settings,
+	                          FreeRDP_RemoteApplicationFile) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationGuid, settings,
+	                          FreeRDP_RemoteApplicationGuid) ||
+	    !FILE_POPULATE_STRING(&file->RemoteApplicationCmdLine, settings,
+	                          FreeRDP_RemoteApplicationCmdLine))
+		return FALSE;
+	file->SpanMonitors = freerdp_settings_get_bool(settings, FreeRDP_SpanMonitors);
+	file->UseMultiMon = freerdp_settings_get_bool(settings, FreeRDP_UseMultimon);
+	file->AllowDesktopComposition =
+	    freerdp_settings_get_bool(settings, FreeRDP_AllowDesktopComposition);
+	file->AllowFontSmoothing = freerdp_settings_get_bool(settings, FreeRDP_AllowFontSmoothing);
+	file->DisableWallpaper = freerdp_settings_get_bool(settings, FreeRDP_DisableWallpaper);
+	file->DisableFullWindowDrag =
+	    freerdp_settings_get_bool(settings, FreeRDP_DisableFullWindowDrag);
+	file->DisableMenuAnims = freerdp_settings_get_bool(settings, FreeRDP_DisableMenuAnims);
+	file->DisableThemes = freerdp_settings_get_bool(settings, FreeRDP_DisableThemes);
+	file->BandwidthAutoDetect =
+	    (freerdp_settings_get_uint32(settings, FreeRDP_ConnectionType) >= 7) ? TRUE : FALSE;
+	file->NetworkAutoDetect =
+	    freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect) ? 1 : 0;
+	file->AutoReconnectionEnabled =
+	    freerdp_settings_get_bool(settings, FreeRDP_AutoReconnectionEnabled);
+	file->RedirectSmartCards = freerdp_settings_get_bool(settings, FreeRDP_RedirectSmartCards);
+	file->RedirectWebauthN = freerdp_settings_get_bool(settings, FreeRDP_RedirectWebAuthN);
+
+	redirectCameras =
+	    freerdp_client_channel_args_to_string(settings, RDPECAM_DVC_CHANNEL_NAME, "device:");
+	if (redirectCameras)
+	{
+		char* str =
+		    freerdp_client_channel_args_to_string(settings, RDPECAM_DVC_CHANNEL_NAME, "encode:");
+		file->EncodeRedirectedVideoCapture = 0;
+		if (str)
+		{
+			unsigned long val = 0;
+			errno = 0;
+			val = strtoul(str, NULL, 0);
+			if ((val < UINT32_MAX) && (errno == 0))
+				file->EncodeRedirectedVideoCapture = val;
+		}
+		free(str);
+
+		str = freerdp_client_channel_args_to_string(settings, RDPECAM_DVC_CHANNEL_NAME, "quality:");
+		file->RedirectedVideoCaptureEncodingQuality = 0;
+		if (str)
+		{
+			unsigned long val = 0;
+			errno = 0;
+			val = strtoul(str, NULL, 0);
+			if ((val <= 2) && (errno == 0))
+			{
+				file->RedirectedVideoCaptureEncodingQuality = val;
+			}
+		}
+		free(str);
+
+		file->RedirectCameras = redirectCameras;
+	}
+#ifdef CHANNEL_URBDRC_CLIENT
+	redirectUsb = freerdp_client_channel_args_to_string(settings, URBDRC_CHANNEL_NAME, "device:");
+	if (redirectUsb)
+		file->UsbDevicesToRedirect = redirectUsb;
+
+#endif
+	file->RedirectClipboard =
+	    freerdp_settings_get_bool(settings, FreeRDP_RedirectClipboard) ? 1 : 0;
+	file->RedirectPrinters = freerdp_settings_get_bool(settings, FreeRDP_RedirectPrinters) ? 1 : 0;
+	file->RedirectDrives = freerdp_settings_get_bool(settings, FreeRDP_RedirectDrives) ? 1 : 0;
+	file->RdgIsKdcProxy = freerdp_settings_get_bool(settings, FreeRDP_KerberosRdgIsProxy) ? 1 : 0;
+	file->RedirectComPorts = (freerdp_settings_get_bool(settings, FreeRDP_RedirectSerialPorts) ||
+	                          freerdp_settings_get_bool(settings, FreeRDP_RedirectParallelPorts));
+	file->RedirectLocation =
+	    freerdp_dynamic_channel_collection_find(settings, LOCATION_DVC_CHANNEL_NAME) ? TRUE : FALSE;
+	if (!FILE_POPULATE_STRING(&file->DrivesToRedirect, settings, FreeRDP_DrivesToRedirect) ||
+	    !FILE_POPULATE_STRING(&file->PreconnectionBlob, settings, FreeRDP_PreconnectionBlob) ||
+	    !FILE_POPULATE_STRING(&file->KdcProxyName, settings, FreeRDP_KerberosKdcUrl))
+		return FALSE;
+
+	{
+		size_t offset = 0;
+		UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+		const UINT32* MonitorIds = freerdp_settings_get_pointer(settings, FreeRDP_MonitorIds);
+		/* String size: 10 char UINT32 max string length, 1 char separator, one element NULL */
+		size_t size = count * (10 + 1) + 1;
+
+		char* str = calloc(size, sizeof(char));
+		for (UINT32 x = 0; x < count; x++)
+		{
+			int rc = _snprintf(&str[offset], size - offset, "%" PRIu32 ",", MonitorIds[x]);
+			if (rc <= 0)
+			{
+				free(str);
+				return FALSE;
+			}
+			offset += (size_t)rc;
+		}
+		if (offset > 0)
+			str[offset - 1] = '\0';
+		freerdp_client_file_string_check_free(file->SelectedMonitors);
+		file->SelectedMonitors = str;
+	}
+
+	file->KeyboardHook = freerdp_settings_get_uint32(settings, FreeRDP_KeyboardHook);
+
+	return TRUE;
+}
+
+BOOL freerdp_client_write_rdp_file(const rdpFile* file, const char* name, BOOL unicode)
+{
+	FILE* fp = NULL;
+	size_t size = 0;
+	char* buffer = NULL;
+	int status = 0;
+	WCHAR* unicodestr = NULL;
+
+	if (!file || !name)
+		return FALSE;
+
+	size = freerdp_client_write_rdp_file_buffer(file, NULL, 0);
+	if (size == 0)
+		return FALSE;
+	buffer = (char*)calloc((size_t)(size + 1), sizeof(char));
+
+	if (freerdp_client_write_rdp_file_buffer(file, buffer, (size_t)size + 1) != size)
+	{
+		WLog_ERR(TAG, "freerdp_client_write_rdp_file: error writing to output buffer");
+		free(buffer);
+		return FALSE;
+	}
+
+	fp = winpr_fopen(name, "w+b");
+
+	if (fp)
+	{
+		if (unicode)
+		{
+			size_t len = 0;
+			unicodestr = ConvertUtf8NToWCharAlloc(buffer, size, &len);
+
+			if (!unicodestr)
+			{
+				free(buffer);
+				fclose(fp);
+				return FALSE;
+			}
+
+			/* Write multi-byte header */
+			if ((fwrite(BOM_UTF16_LE, sizeof(BYTE), 2, fp) != 2) ||
+			    (fwrite(unicodestr, sizeof(WCHAR), len, fp) != len))
+			{
+				free(buffer);
+				free(unicodestr);
+				fclose(fp);
+				return FALSE;
+			}
+
+			free(unicodestr);
+		}
+		else
+		{
+			if (fwrite(buffer, 1, (size_t)size, fp) != (size_t)size)
+			{
+				free(buffer);
+				fclose(fp);
+				return FALSE;
+			}
+		}
+
+		fflush(fp);
+		status = fclose(fp);
+	}
+
+	free(buffer);
+	return (status == 0) ? TRUE : FALSE;
+}
+
+WINPR_ATTR_FORMAT_ARG(3, 4)
+static SSIZE_T freerdp_client_write_setting_to_buffer(char** buffer, size_t* bufferSize,
+                                                      WINPR_FORMAT_ARG const char* fmt, ...)
+{
+	va_list ap;
+	SSIZE_T len = 0;
+	char* buf = NULL;
+	size_t bufSize = 0;
+
+	if (!buffer || !bufferSize || !fmt)
+		return -1;
+
+	buf = *buffer;
+	bufSize = *bufferSize;
+
+	va_start(ap, fmt);
+	len = vsnprintf(buf, bufSize, fmt, ap);
+	va_end(ap);
+	if (len < 0)
+		return -1;
+
+	/* _snprintf doesn't add the ending \0 to its return value */
+	++len;
+
+	/* we just want to know the size - return it */
+	if (!buf && !bufSize)
+		return len;
+
+	if (!buf)
+		return -1;
+
+	/* update buffer size and buffer position and replace \0 with \n */
+	if (bufSize >= (size_t)len)
+	{
+		*bufferSize -= (size_t)len;
+		buf[len - 1] = '\n';
+		*buffer = buf + len;
+	}
+	else
+		return -1;
+
+	return len;
+}
+
+size_t freerdp_client_write_rdp_file_buffer(const rdpFile* file, char* buffer, size_t size)
+{
+	size_t totalSize = 0;
+
+	if (!file)
+		return 0;
+
+	/* either buffer and size are null or non-null */
+	if ((!buffer || !size) && (buffer || size))
+		return 0;
+
+#define WRITE_SETTING_(fmt_, ...)                                                                \
+	{                                                                                            \
+		SSIZE_T res = freerdp_client_write_setting_to_buffer(&buffer, &size, fmt_, __VA_ARGS__); \
+		if (res < 0)                                                                             \
+			return 0;                                                                            \
+		totalSize += (size_t)res;                                                                \
+	}
+
+#define WRITE_SETTING_INT(key_, param_)                   \
+	do                                                    \
+	{                                                     \
+		if (~(param_))                                    \
+			WRITE_SETTING_("%s:i:%" PRIu32, key_, param_) \
+	} while (0)
+
+#define WRITE_SETTING_STR(key_, param_)             \
+	do                                              \
+	{                                               \
+		if (~(size_t)(param_))                      \
+			WRITE_SETTING_("%s:s:%s", key_, param_) \
+	} while (0)
+
+	/* integer parameters */
+	WRITE_SETTING_INT(key_int_use_multimon, file->UseMultiMon);
+	WRITE_SETTING_INT(key_int_maximizetocurrentdisplays, file->MaximizeToCurrentDisplays);
+	WRITE_SETTING_INT(key_int_singlemoninwindowedmode, file->SingleMonInWindowedMode);
+	WRITE_SETTING_INT(key_int_screen_mode_id, file->ScreenModeId);
+	WRITE_SETTING_INT(key_int_span_monitors, file->SpanMonitors);
+	WRITE_SETTING_INT(key_int_smart_sizing, file->SmartSizing);
+	WRITE_SETTING_INT(key_int_dynamic_resolution, file->DynamicResolution);
+	WRITE_SETTING_INT(key_int_enablesuperpan, file->EnableSuperSpan);
+	WRITE_SETTING_INT(key_int_superpanaccelerationfactor, file->SuperSpanAccelerationFactor);
+	WRITE_SETTING_INT(key_int_desktopwidth, file->DesktopWidth);
+	WRITE_SETTING_INT(key_int_desktopheight, file->DesktopHeight);
+	WRITE_SETTING_INT(key_int_desktop_size_id, file->DesktopSizeId);
+	WRITE_SETTING_INT(key_int_session_bpp, file->SessionBpp);
+	WRITE_SETTING_INT(key_int_desktopscalefactor, file->DesktopScaleFactor);
+	WRITE_SETTING_INT(key_int_compression, file->Compression);
+	WRITE_SETTING_INT(key_int_keyboardhook, file->KeyboardHook);
+	WRITE_SETTING_INT(key_int_disable_ctrl_alt_del, file->DisableCtrlAltDel);
+	WRITE_SETTING_INT(key_int_audiomode, file->AudioMode);
+	WRITE_SETTING_INT(key_int_audioqualitymode, file->AudioQualityMode);
+	WRITE_SETTING_INT(key_int_audiocapturemode, file->AudioCaptureMode);
+	WRITE_SETTING_INT(key_int_encode_redirected_video_capture, file->EncodeRedirectedVideoCapture);
+	WRITE_SETTING_INT(key_int_redirected_video_capture_encoding_quality,
+	                  file->RedirectedVideoCaptureEncodingQuality);
+	WRITE_SETTING_INT(key_int_videoplaybackmode, file->VideoPlaybackMode);
+	WRITE_SETTING_INT(key_int_connection_type, file->ConnectionType);
+	WRITE_SETTING_INT(key_int_networkautodetect, file->NetworkAutoDetect);
+	WRITE_SETTING_INT(key_int_bandwidthautodetect, file->BandwidthAutoDetect);
+	WRITE_SETTING_INT(key_int_pinconnectionbar, file->PinConnectionBar);
+	WRITE_SETTING_INT(key_int_displayconnectionbar, file->DisplayConnectionBar);
+	WRITE_SETTING_INT(key_int_workspaceid, file->WorkspaceId);
+	WRITE_SETTING_INT(key_int_enableworkspacereconnect, file->EnableWorkspaceReconnect);
+	WRITE_SETTING_INT(key_int_disable_wallpaper, file->DisableWallpaper);
+	WRITE_SETTING_INT(key_int_allow_font_smoothing, file->AllowFontSmoothing);
+	WRITE_SETTING_INT(key_int_allow_desktop_composition, file->AllowDesktopComposition);
+	WRITE_SETTING_INT(key_int_disable_full_window_drag, file->DisableFullWindowDrag);
+	WRITE_SETTING_INT(key_int_disable_menu_anims, file->DisableMenuAnims);
+	WRITE_SETTING_INT(key_int_disable_themes, file->DisableThemes);
+	WRITE_SETTING_INT(key_int_disable_cursor_setting, file->DisableCursorSetting);
+	WRITE_SETTING_INT(key_int_bitmapcachesize, file->BitmapCacheSize);
+	WRITE_SETTING_INT(key_int_bitmapcachepersistenable, file->BitmapCachePersistEnable);
+	WRITE_SETTING_INT(key_int_server_port, file->ServerPort);
+	WRITE_SETTING_INT(key_int_redirectdrives, file->RedirectDrives);
+	WRITE_SETTING_INT(key_int_redirectprinters, file->RedirectPrinters);
+	WRITE_SETTING_INT(key_int_redirectcomports, file->RedirectComPorts);
+	WRITE_SETTING_INT(key_int_redirectlocation, file->RedirectLocation);
+	WRITE_SETTING_INT(key_int_redirectsmartcards, file->RedirectSmartCards);
+	WRITE_SETTING_INT(key_int_redirectclipboard, file->RedirectClipboard);
+	WRITE_SETTING_INT(key_int_redirectposdevices, file->RedirectPosDevices);
+	WRITE_SETTING_INT(key_int_redirectdirectx, file->RedirectDirectX);
+	WRITE_SETTING_INT(key_int_disableprinterredirection, file->DisablePrinterRedirection);
+	WRITE_SETTING_INT(key_int_disableclipboardredirection, file->DisableClipboardRedirection);
+	WRITE_SETTING_INT(key_int_connect_to_console, file->ConnectToConsole);
+	WRITE_SETTING_INT(key_int_administrative_session, file->AdministrativeSession);
+	WRITE_SETTING_INT(key_int_autoreconnection_enabled, file->AutoReconnectionEnabled);
+	WRITE_SETTING_INT(key_int_autoreconnect_max_retries, file->AutoReconnectMaxRetries);
+	WRITE_SETTING_INT(key_int_public_mode, file->PublicMode);
+	WRITE_SETTING_INT(key_int_authentication_level, file->AuthenticationLevel);
+	WRITE_SETTING_INT(key_int_promptcredentialonce, file->PromptCredentialOnce);
+	WRITE_SETTING_INT(key_int_prompt_for_credentials, file->PromptForCredentials);
+	WRITE_SETTING_INT(key_int_negotiate_security_layer, file->NegotiateSecurityLayer);
+	WRITE_SETTING_INT(key_int_enablecredsspsupport, file->EnableCredSSPSupport);
+	WRITE_SETTING_INT(key_int_enablerdsaadauth, file->EnableRdsAadAuth);
+	WRITE_SETTING_INT(key_int_remoteapplicationmode, file->RemoteApplicationMode);
+	WRITE_SETTING_INT(key_int_remoteapplicationexpandcmdline, file->RemoteApplicationExpandCmdLine);
+	WRITE_SETTING_INT(key_int_remoteapplicationexpandworkingdir,
+	                  file->RemoteApplicationExpandWorkingDir);
+	WRITE_SETTING_INT(key_int_disableconnectionsharing, file->DisableConnectionSharing);
+	WRITE_SETTING_INT(key_int_disableremoteappcapscheck, file->DisableRemoteAppCapsCheck);
+	WRITE_SETTING_INT(key_int_gatewayusagemethod, file->GatewayUsageMethod);
+	WRITE_SETTING_INT(key_int_gatewayprofileusagemethod, file->GatewayProfileUsageMethod);
+	WRITE_SETTING_INT(key_int_gatewaycredentialssource, file->GatewayCredentialsSource);
+	WRITE_SETTING_INT(key_int_use_redirection_server_name, file->UseRedirectionServerName);
+	WRITE_SETTING_INT(key_int_rdgiskdcproxy, file->RdgIsKdcProxy);
+	WRITE_SETTING_INT(key_int_redirectwebauthn, file->RedirectWebauthN);
+
+	/* string parameters */
+	WRITE_SETTING_STR(key_str_username, file->Username);
+	WRITE_SETTING_STR(key_str_domain, file->Domain);
+	WRITE_SETTING_STR(key_str_password, file->Password);
+	WRITE_SETTING_STR(key_str_full_address, file->FullAddress);
+	WRITE_SETTING_STR(key_str_alternate_full_address, file->AlternateFullAddress);
+	WRITE_SETTING_STR(key_str_usbdevicestoredirect, file->UsbDevicesToRedirect);
+	WRITE_SETTING_STR(key_str_camerastoredirect, file->RedirectCameras);
+	WRITE_SETTING_STR(key_str_loadbalanceinfo, file->LoadBalanceInfo);
+	WRITE_SETTING_STR(key_str_remoteapplicationname, file->RemoteApplicationName);
+	WRITE_SETTING_STR(key_str_remoteapplicationicon, file->RemoteApplicationIcon);
+	WRITE_SETTING_STR(key_str_remoteapplicationprogram, file->RemoteApplicationProgram);
+	WRITE_SETTING_STR(key_str_remoteapplicationfile, file->RemoteApplicationFile);
+	WRITE_SETTING_STR(key_str_remoteapplicationguid, file->RemoteApplicationGuid);
+	WRITE_SETTING_STR(key_str_remoteapplicationcmdline, file->RemoteApplicationCmdLine);
+	WRITE_SETTING_STR(key_str_alternate_shell, file->AlternateShell);
+	WRITE_SETTING_STR(key_str_shell_working_directory, file->ShellWorkingDirectory);
+	WRITE_SETTING_STR(key_str_gatewayhostname, file->GatewayHostname);
+	WRITE_SETTING_STR(key_str_resourceprovider, file->ResourceProvider);
+	WRITE_SETTING_STR(key_str_wvd, file->WvdEndpointPool);
+	WRITE_SETTING_STR(key_str_geo, file->geo);
+	WRITE_SETTING_STR(key_str_armpath, file->armpath);
+	WRITE_SETTING_STR(key_str_aadtenantid, file->aadtenantid);
+	WRITE_SETTING_STR(key_str_diagnosticserviceurl, file->diagnosticserviceurl);
+	WRITE_SETTING_STR(key_str_hubdiscoverygeourl, file->hubdiscoverygeourl);
+	WRITE_SETTING_STR(key_str_activityhint, file->activityhint);
+	WRITE_SETTING_STR(key_str_gatewayaccesstoken, file->GatewayAccessToken);
+	WRITE_SETTING_STR(key_str_kdcproxyname, file->KdcProxyName);
+	WRITE_SETTING_STR(key_str_drivestoredirect, file->DrivesToRedirect);
+	WRITE_SETTING_STR(key_str_devicestoredirect, file->DevicesToRedirect);
+	WRITE_SETTING_STR(key_str_winposstr, file->WinPosStr);
+	WRITE_SETTING_STR(key_str_pcb, file->PreconnectionBlob);
+	WRITE_SETTING_STR(key_str_selectedmonitors, file->SelectedMonitors);
+
+	/* custom parameters */
+	for (size_t i = 0; i < file->lineCount; ++i)
+	{
+		SSIZE_T res = -1;
+		const rdpFileLine* curLine = &file->lines[i];
+
+		if (curLine->flags & RDP_FILE_LINE_FLAG_TYPE_INTEGER)
+			res = freerdp_client_write_setting_to_buffer(&buffer, &size, "%s:i:%" PRIu32,
+			                                             curLine->name, (UINT32)curLine->iValue);
+		else if (curLine->flags & RDP_FILE_LINE_FLAG_TYPE_STRING)
+			res = freerdp_client_write_setting_to_buffer(&buffer, &size, "%s:s:%s", curLine->name,
+			                                             curLine->sValue);
+		if (res < 0)
+			return 0;
+
+		totalSize += (size_t)res;
+	}
+
+	return totalSize;
+}
+
+static ADDIN_ARGV* rdp_file_to_args(const char* channel, const char* values)
+{
+	size_t count = 0;
+	char** p = NULL;
+	ADDIN_ARGV* args = freerdp_addin_argv_new(0, NULL);
+	if (!args)
+		return NULL;
+	if (!freerdp_addin_argv_add_argument(args, channel))
+		goto fail;
+
+	p = CommandLineParseCommaSeparatedValues(values, &count);
+	for (size_t x = 0; x < count; x++)
+	{
+		BOOL rc = 0;
+		const char* val = p[x];
+		const size_t len = strlen(val) + 8;
+		char* str = calloc(len, sizeof(char));
+		if (!str)
+			goto fail;
+
+		_snprintf(str, len, "device:%s", val);
+		rc = freerdp_addin_argv_add_argument(args, str);
+		free(str);
+		if (!rc)
+			goto fail;
+	}
+	free(p);
+	return args;
+
+fail:
+	free(p);
+	freerdp_addin_argv_free(args);
+	return NULL;
+}
+
+BOOL freerdp_client_populate_settings_from_rdp_file(const rdpFile* file, rdpSettings* settings)
+{
+	BOOL setDefaultConnectionType = TRUE;
+
+	if (!file || !settings)
+		return FALSE;
+
+	if (~((size_t)file->Domain))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_Domain, file->Domain))
+			return FALSE;
+	}
+
+	if (~((size_t)file->Username))
+	{
+		char* user = NULL;
+		char* domain = NULL;
+
+		if (!freerdp_parse_username(file->Username, &user, &domain))
+			return FALSE;
+
+		if (!freerdp_settings_set_string(settings, FreeRDP_Username, user))
+			return FALSE;
+
+		if (!(~((size_t)file->Domain)) && domain)
+		{
+			if (!freerdp_settings_set_string(settings, FreeRDP_Domain, domain))
+				return FALSE;
+		}
+
+		free(user);
+		free(domain);
+	}
+
+	if (~((size_t)file->Password))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_Password, file->Password))
+			return FALSE;
+	}
+
+	{
+		const char* address = NULL;
+
+		/* With MSTSC alternate full address always wins,
+		 * so mimic this. */
+		if (~((size_t)file->AlternateFullAddress))
+			address = file->AlternateFullAddress;
+		else if (~((size_t)file->FullAddress))
+			address = file->FullAddress;
+
+		if (address)
+		{
+			int port = -1;
+			char* host = NULL;
+
+			if (!freerdp_parse_hostname(address, &host, &port))
+				return FALSE;
+
+			const BOOL rc = freerdp_settings_set_string(settings, FreeRDP_ServerHostname, host);
+			free(host);
+			if (!rc)
+				return FALSE;
+
+			if (port > 0)
+			{
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, (UINT32)port))
+					return FALSE;
+			}
+		}
+	}
+
+	if (~file->ServerPort)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, file->ServerPort))
+			return FALSE;
+	}
+
+	if (~file->DesktopSizeId)
+	{
+		switch (file->DesktopSizeId)
+		{
+			case 0:
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 640))
+					return FALSE;
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 480))
+					return FALSE;
+				break;
+			case 1:
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 800))
+					return FALSE;
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 600))
+					return FALSE;
+				break;
+			case 2:
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 1024))
+					return FALSE;
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 768))
+					return FALSE;
+				break;
+			case 3:
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 1280))
+					return FALSE;
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 1024))
+					return FALSE;
+				break;
+			case 4:
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 1600))
+					return FALSE;
+				if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 1200))
+					return FALSE;
+				break;
+			default:
+				WLog_WARN(TAG, "Unsupported 'desktop size id' value %" PRIu32, file->DesktopSizeId);
+				break;
+		}
+	}
+	if (~file->DesktopWidth)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, file->DesktopWidth))
+			return FALSE;
+	}
+
+	if (~file->DesktopHeight)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, file->DesktopHeight))
+			return FALSE;
+	}
+
+	if (~file->SessionBpp)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, file->SessionBpp))
+			return FALSE;
+	}
+
+	if (~file->ConnectToConsole)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_ConsoleSession,
+		                               file->ConnectToConsole != 0))
+			return FALSE;
+	}
+
+	if (~file->AdministrativeSession)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_ConsoleSession,
+		                               file->AdministrativeSession != 0))
+			return FALSE;
+	}
+
+	if (~file->NegotiateSecurityLayer)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_NegotiateSecurityLayer,
+		                               file->NegotiateSecurityLayer != 0))
+			return FALSE;
+	}
+
+	if (~file->EnableCredSSPSupport)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity,
+		                               file->EnableCredSSPSupport != 0))
+			return FALSE;
+	}
+
+	if (~file->EnableRdsAadAuth)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_AadSecurity, file->EnableRdsAadAuth != 0))
+			return FALSE;
+	}
+
+	if (~((size_t)file->AlternateShell))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_AlternateShell, file->AlternateShell))
+			return FALSE;
+	}
+
+	if (~((size_t)file->ShellWorkingDirectory))
+	{
+		/* ShellWorkingDir is used for either, shell working dir or remote app working dir */
+		FreeRDP_Settings_Keys_String targetId =
+		    (~file->RemoteApplicationMode && file->RemoteApplicationMode != 0)
+		        ? FreeRDP_RemoteApplicationWorkingDir
+		        : FreeRDP_ShellWorkingDirectory;
+
+		if (!freerdp_settings_set_string(settings, targetId, file->ShellWorkingDirectory))
+			return FALSE;
+	}
+
+	if (~file->ScreenModeId)
+	{
+		/**
+		 * Screen Mode Id:
+		 * http://technet.microsoft.com/en-us/library/ff393692/
+		 *
+		 * This setting corresponds to the selection in the Display
+		 * configuration slider on the Display tab under Options in RDC.
+		 *
+		 * Values:
+		 *
+		 * 1: The remote session will appear in a window.
+		 * 2: The remote session will appear full screen.
+		 */
+		if (!freerdp_settings_set_bool(settings, FreeRDP_Fullscreen,
+		                               (file->ScreenModeId == 2) ? TRUE : FALSE))
+			return FALSE;
+	}
+
+	if (~(file->SmartSizing))
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_SmartSizing,
+		                               (file->SmartSizing == 1) ? TRUE : FALSE))
+			return FALSE;
+		/**
+		 *  SmartSizingWidth and SmartSizingHeight:
+		 *
+		 *  Adding this option to use the DesktopHeight	and DesktopWidth as
+		 *  parameters for the SmartSizingWidth and SmartSizingHeight, as there
+		 *  are no options for that in standard RDP files.
+		 *
+		 *  Equivalent of doing /smart-sizing:WxH
+		 */
+		if (((~(file->DesktopWidth) && ~(file->DesktopHeight)) || ~(file->DesktopSizeId)) &&
+		    (file->SmartSizing == 1))
+		{
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_SmartSizingWidth,
+			                                 file->DesktopWidth))
+				return FALSE;
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_SmartSizingHeight,
+			                                 file->DesktopHeight))
+				return FALSE;
+		}
+	}
+
+	if (~((size_t)file->LoadBalanceInfo))
+	{
+		const size_t len = strlen(file->LoadBalanceInfo);
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_LoadBalanceInfo,
+		                                      file->LoadBalanceInfo, len))
+			return FALSE;
+	}
+
+	if (~file->AuthenticationLevel)
+	{
+		/**
+		 * Authentication Level:
+		 * http://technet.microsoft.com/en-us/library/ff393709/
+		 *
+		 * This setting corresponds to the selection in the If server authentication
+		 * fails drop-down list on the Advanced tab under Options in RDC.
+		 *
+		 * Values:
+		 *
+		 * 0: If server authentication fails, connect to the computer without warning (Connect and
+		 * don’t warn me). 1: If server authentication fails, do not establish a connection (Do not
+		 * connect). 2: If server authentication fails, show a warning and allow me to connect or
+		 * refuse the connection (Warn me). 3: No authentication requirement is specified.
+		 */
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_AuthenticationLevel,
+		                                 file->AuthenticationLevel))
+			return FALSE;
+	}
+
+	if (~file->ConnectionType)
+	{
+		if (!freerdp_set_connection_type(settings, file->ConnectionType))
+			return FALSE;
+		setDefaultConnectionType = FALSE;
+	}
+
+	if (~file->AudioMode)
+	{
+		switch (file->AudioMode)
+		{
+			case AUDIO_MODE_REDIRECT:
+				if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteConsoleAudio, FALSE))
+					return FALSE;
+				if (!freerdp_settings_set_bool(settings, FreeRDP_AudioPlayback, TRUE))
+					return FALSE;
+				break;
+			case AUDIO_MODE_PLAY_ON_SERVER:
+				if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteConsoleAudio, TRUE))
+					return FALSE;
+				if (!freerdp_settings_set_bool(settings, FreeRDP_AudioPlayback, FALSE))
+					return FALSE;
+				break;
+			case AUDIO_MODE_NONE:
+			default:
+				if (!freerdp_settings_set_bool(settings, FreeRDP_AudioPlayback, FALSE))
+					return FALSE;
+				if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteConsoleAudio, FALSE))
+					return FALSE;
+				break;
+		}
+	}
+
+	if (~file->AudioCaptureMode)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_AudioCapture, file->AudioCaptureMode != 0))
+			return FALSE;
+	}
+
+	if (~file->Compression)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_CompressionEnabled,
+		                               file->Compression != 0))
+			return FALSE;
+	}
+
+	if (~((size_t)file->GatewayHostname))
+	{
+		int port = -1;
+		char* host = NULL;
+
+		if (!freerdp_parse_hostname(file->GatewayHostname, &host, &port))
+			return FALSE;
+
+		const BOOL rc = freerdp_settings_set_string(settings, FreeRDP_GatewayHostname, host);
+		free(host);
+		if (!rc)
+			return FALSE;
+
+		if (port > 0)
+		{
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_GatewayPort, (UINT32)port))
+				return FALSE;
+		}
+	}
+
+	if (~((size_t)file->ResourceProvider))
+	{
+		if (_stricmp(file->ResourceProvider, str_resourceprovider_arm) == 0)
+		{
+			if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayArmTransport, TRUE))
+				return FALSE;
+		}
+	}
+
+	if (~((size_t)file->WvdEndpointPool))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdWvdEndpointPool,
+		                                 file->WvdEndpointPool))
+			return FALSE;
+	}
+
+	if (~((size_t)file->geo))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdGeo, file->geo))
+			return FALSE;
+	}
+
+	if (~((size_t)file->armpath))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdArmpath, file->armpath))
+			return FALSE;
+	}
+
+	if (~((size_t)file->aadtenantid))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdAadtenantid,
+		                                 file->aadtenantid))
+			return FALSE;
+	}
+
+	if (~((size_t)file->diagnosticserviceurl))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdDiagnosticserviceurl,
+		                                 file->diagnosticserviceurl))
+			return FALSE;
+	}
+
+	if (~((size_t)file->hubdiscoverygeourl))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdHubdiscoverygeourl,
+		                                 file->hubdiscoverygeourl))
+			return FALSE;
+	}
+
+	if (~((size_t)file->activityhint))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAvdActivityhint,
+		                                 file->activityhint))
+			return FALSE;
+	}
+
+	if (~((size_t)file->GatewayAccessToken))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_GatewayAccessToken,
+		                                 file->GatewayAccessToken))
+			return FALSE;
+	}
+
+	if (~file->GatewayUsageMethod)
+	{
+		if (!freerdp_set_gateway_usage_method(settings, file->GatewayUsageMethod))
+			return FALSE;
+	}
+
+	if (~file->PromptCredentialOnce)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayUseSameCredentials,
+		                               file->PromptCredentialOnce != 0))
+			return FALSE;
+	}
+
+	if (~file->PromptForCredentials)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_PromptForCredentials,
+		                               file->PromptForCredentials != 0))
+			return FALSE;
+	}
+
+	if (~file->RemoteApplicationMode)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteApplicationMode,
+		                               file->RemoteApplicationMode != 0))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationProgram))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationProgram,
+		                                 file->RemoteApplicationProgram))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationName))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationName,
+		                                 file->RemoteApplicationName))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationIcon))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationIcon,
+		                                 file->RemoteApplicationIcon))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationFile))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationFile,
+		                                 file->RemoteApplicationFile))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationGuid))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationGuid,
+		                                 file->RemoteApplicationGuid))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RemoteApplicationCmdLine))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_RemoteApplicationCmdLine,
+		                                 file->RemoteApplicationCmdLine))
+			return FALSE;
+	}
+
+	if (~file->SpanMonitors)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_SpanMonitors, file->SpanMonitors != 0))
+			return FALSE;
+	}
+
+	if (~file->UseMultiMon)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_UseMultimon, file->UseMultiMon != 0))
+			return FALSE;
+	}
+
+	if (~file->AllowFontSmoothing)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing,
+		                               file->AllowFontSmoothing != 0))
+			return FALSE;
+	}
+
+	if (~file->DisableWallpaper)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DisableWallpaper,
+		                               file->DisableWallpaper != 0))
+			return FALSE;
+	}
+
+	if (~file->DisableFullWindowDrag)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag,
+		                               file->DisableFullWindowDrag != 0))
+			return FALSE;
+	}
+
+	if (~file->DisableMenuAnims)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims,
+		                               file->DisableMenuAnims != 0))
+			return FALSE;
+	}
+
+	if (~file->DisableThemes)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DisableThemes, file->DisableThemes != 0))
+			return FALSE;
+	}
+
+	if (~file->AllowDesktopComposition)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition,
+		                               file->AllowDesktopComposition != 0))
+			return FALSE;
+	}
+
+	if (~file->BitmapCachePersistEnable)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_BitmapCachePersistEnabled,
+		                               file->BitmapCachePersistEnable != 0))
+			return FALSE;
+	}
+
+	if (~file->DisableRemoteAppCapsCheck)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DisableRemoteAppCapsCheck,
+		                               file->DisableRemoteAppCapsCheck != 0))
+			return FALSE;
+	}
+
+	if (~file->BandwidthAutoDetect)
+	{
+		if (file->BandwidthAutoDetect != 0)
+		{
+			if ((~file->NetworkAutoDetect) && (file->NetworkAutoDetect == 0))
+			{
+				WLog_WARN(TAG,
+				          "Got networkautodetect:i:%" PRIu32 " and bandwidthautodetect:i:%" PRIu32
+				          ". Correcting to networkautodetect:i:1",
+				          file->NetworkAutoDetect, file->BandwidthAutoDetect);
+				WLog_WARN(TAG,
+				          "Add networkautodetect:i:1 to your RDP file to eliminate this warning.");
+			}
+
+			if (!freerdp_set_connection_type(settings, CONNECTION_TYPE_AUTODETECT))
+				return FALSE;
+			setDefaultConnectionType = FALSE;
+		}
+		if (!freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect,
+		                               (file->BandwidthAutoDetect != 0) ||
+		                                   (file->NetworkAutoDetect != 0)))
+			return FALSE;
+	}
+
+	if (~file->NetworkAutoDetect)
+	{
+		if (file->NetworkAutoDetect != 0)
+		{
+			if ((~file->BandwidthAutoDetect) && (file->BandwidthAutoDetect == 0))
+			{
+				WLog_WARN(TAG,
+				          "Got networkautodetect:i:%" PRIu32 " and bandwidthautodetect:i:%" PRIu32
+				          ". Correcting to bandwidthautodetect:i:1",
+				          file->NetworkAutoDetect, file->BandwidthAutoDetect);
+				WLog_WARN(
+				    TAG, "Add bandwidthautodetect:i:1 to your RDP file to eliminate this warning.");
+			}
+
+			if (!freerdp_set_connection_type(settings, CONNECTION_TYPE_AUTODETECT))
+				return FALSE;
+
+			setDefaultConnectionType = FALSE;
+		}
+		if (!freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect,
+		                               (file->BandwidthAutoDetect != 0) ||
+		                                   (file->NetworkAutoDetect != 0)))
+			return FALSE;
+	}
+
+	if (~file->AutoReconnectionEnabled)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_AutoReconnectionEnabled,
+		                               file->AutoReconnectionEnabled != 0))
+			return FALSE;
+	}
+
+	if (~file->AutoReconnectMaxRetries)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_AutoReconnectMaxRetries,
+		                                 file->AutoReconnectMaxRetries))
+			return FALSE;
+	}
+
+	if (~file->RedirectSmartCards)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectSmartCards,
+		                               file->RedirectSmartCards != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectWebauthN)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectWebAuthN,
+		                               file->RedirectWebauthN != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectClipboard)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectClipboard,
+		                               file->RedirectClipboard != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectPrinters)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectPrinters,
+		                               file->RedirectPrinters != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectDrives)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectDrives, file->RedirectDrives != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectPosDevices)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectSerialPorts,
+		                               file->RedirectComPorts != 0) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_RedirectParallelPorts,
+		                               file->RedirectComPorts != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectComPorts)
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectSerialPorts,
+		                               file->RedirectComPorts != 0) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_RedirectParallelPorts,
+		                               file->RedirectComPorts != 0))
+			return FALSE;
+	}
+
+	if (~file->RedirectLocation)
+	{
+		size_t count = 0;
+		char** str =
+		    CommandLineParseCommaSeparatedValuesEx(LOCATION_DVC_CHANNEL_NAME, NULL, &count);
+		const BOOL rc = freerdp_client_add_dynamic_channel(settings, count, str);
+		free(str);
+		if (!rc)
+			return FALSE;
+	}
+
+	if (~file->RedirectDirectX)
+	{
+		/* What is this?! */
+	}
+
+	if (~((size_t)file->DevicesToRedirect))
+	{
+		/**
+		 * Devices to redirect:
+		 * http://technet.microsoft.com/en-us/library/ff393728/
+		 *
+		 * This setting corresponds to the selections for Other supported Plug and Play
+		 * (PnP) devices under More on the Local Resources tab under Options in RDC.
+		 *
+		 * Values:
+		 *
+		 * '*':
+		 * 	Redirect all supported Plug and Play devices.
+		 *
+		 * 'DynamicDevices':
+		 * 	Redirect any supported Plug and Play devices that are connected later.
+		 *
+		 * The hardware ID for the supported Plug and Play device:
+		 * 	Redirect the specified supported Plug and Play device.
+		 *
+		 * Examples:
+		 * 	devicestoredirect:s:*
+		 * 	devicestoredirect:s:DynamicDevices
+		 * 	devicestoredirect:s:USB\VID_04A9&PID_30C1\6&4BD985D&0&2;,DynamicDevices
+		 *
+		 */
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DeviceRedirection, TRUE))
+			return FALSE;
+	}
+
+	if (~((size_t)file->DrivesToRedirect))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_DrivesToRedirect,
+		                                 file->DrivesToRedirect))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RedirectCameras))
+	{
+#if defined(CHANNEL_RDPECAM_CLIENT)
+		union
+		{
+			char** c;
+			const char** cc;
+		} cnv;
+		ADDIN_ARGV* args = rdp_file_to_args(RDPECAM_DVC_CHANNEL_NAME, file->RedirectCameras);
+		if (!args)
+			return FALSE;
+
+		if (~file->EncodeRedirectedVideoCapture)
+		{
+			char encode[64];
+			_snprintf(encode, sizeof(encode), "encode:%" PRIu32,
+			          file->EncodeRedirectedVideoCapture);
+			freerdp_addin_argv_add_argument(args, encode);
+		}
+		if (~file->RedirectedVideoCaptureEncodingQuality)
+		{
+			char quality[64];
+			_snprintf(quality, sizeof(quality), "quality:%" PRIu32,
+			          file->RedirectedVideoCaptureEncodingQuality);
+			freerdp_addin_argv_add_argument(args, quality);
+		}
+
+		cnv.c = args->argv;
+		const BOOL status = freerdp_client_add_dynamic_channel(settings, args->argc, cnv.cc);
+		freerdp_addin_argv_free(args);
+		if (!status)
+			return FALSE;
+#else
+		WLog_WARN(
+		    TAG,
+		    "This build does not support [MS-RDPECAM] camera redirection channel. Ignoring '%s'",
+		    key_str_camerastoredirect);
+#endif
+	}
+
+	if (~((size_t)file->UsbDevicesToRedirect))
+	{
+#ifdef CHANNEL_URBDRC_CLIENT
+		union
+		{
+			char** c;
+			const char** cc;
+		} cnv;
+		ADDIN_ARGV* args = rdp_file_to_args(URBDRC_CHANNEL_NAME, file->UsbDevicesToRedirect);
+		if (!args)
+			return FALSE;
+		cnv.c = args->argv;
+		const BOOL status = freerdp_client_add_dynamic_channel(settings, args->argc, cnv.cc);
+		freerdp_addin_argv_free(args);
+		if (!status)
+			return FALSE;
+#else
+		WLog_WARN(TAG,
+		          "This build does not support [MS-RDPEUSB] usb redirection channel. Ignoring '%s'",
+		          key_str_usbdevicestoredirect);
+#endif
+	}
+
+	if (~file->KeyboardHook)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_KeyboardHook, file->KeyboardHook))
+			return FALSE;
+	}
+
+	if (~(size_t)file->SelectedMonitors)
+	{
+		size_t count = 0;
+		char** args = CommandLineParseCommaSeparatedValues(file->SelectedMonitors, &count);
+		UINT32* list = NULL;
+
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, NULL, count))
+		{
+			free(args);
+			return FALSE;
+		}
+		list = freerdp_settings_get_pointer_writable(settings, FreeRDP_MonitorIds);
+		if (!list && (count > 0))
+		{
+			free(args);
+			return FALSE;
+		}
+		for (size_t x = 0; x < count; x++)
+		{
+			unsigned long val = 0;
+			errno = 0;
+			val = strtoul(args[x], NULL, 0);
+			if ((val >= UINT32_MAX) && (errno != 0))
+			{
+				free(args);
+				free(list);
+				return FALSE;
+			}
+			list[x] = val;
+		}
+		free(args);
+	}
+
+	if (~file->DynamicResolution)
+	{
+		const BOOL val = file->DynamicResolution != 0;
+		if (val)
+		{
+			if (!freerdp_settings_set_bool(settings, FreeRDP_SupportDisplayControl, TRUE))
+				return FALSE;
+		}
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DynamicResolutionUpdate, val))
+			return FALSE;
+	}
+
+	if (~file->DesktopScaleFactor)
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopScaleFactor,
+		                                 file->DesktopScaleFactor))
+			return FALSE;
+	}
+
+	if (~file->VideoPlaybackMode)
+	{
+		if (file->VideoPlaybackMode != 0)
+		{
+			if (!freerdp_settings_set_bool(settings, FreeRDP_SupportGeometryTracking, TRUE) ||
+			    !freerdp_settings_set_bool(settings, FreeRDP_SupportVideoOptimized, TRUE))
+				return FALSE;
+		}
+		else
+		{
+			if (!freerdp_settings_set_bool(settings, FreeRDP_SupportVideoOptimized, FALSE))
+				return FALSE;
+		}
+	}
+	// TODO file->MaximizeToCurrentDisplays;
+	// TODO file->SingleMonInWindowedMode;
+	// TODO file->EncodeRedirectedVideoCapture;
+	// TODO file->RedirectedVideoCaptureEncodingQuality;
+
+	if (~((size_t)file->PreconnectionBlob))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_PreconnectionBlob,
+		                                 file->PreconnectionBlob) ||
+		    !freerdp_settings_set_bool(settings, FreeRDP_SendPreconnectionPdu, TRUE))
+			return FALSE;
+	}
+
+	if (~((size_t)file->KdcProxyName))
+	{
+		if (!freerdp_settings_set_string(settings, FreeRDP_KerberosKdcUrl, file->KdcProxyName))
+			return FALSE;
+	}
+
+	if (~((size_t)file->RdgIsKdcProxy))
+	{
+		if (!freerdp_settings_set_bool(settings, FreeRDP_KerberosRdgIsProxy,
+		                               file->RdgIsKdcProxy != 0))
+			return FALSE;
+	}
+
+	if (file->args->argc > 1)
+	{
+		WCHAR* ConnectionFile =
+		    freerdp_settings_get_string_as_utf16(settings, FreeRDP_ConnectionFile, NULL);
+
+		if (freerdp_client_settings_parse_command_line(settings, file->args->argc, file->args->argv,
+		                                               FALSE) < 0)
+		{
+			free(ConnectionFile);
+			return FALSE;
+		}
+
+		BOOL rc = freerdp_settings_set_string_from_utf16(settings, FreeRDP_ConnectionFile,
+		                                                 ConnectionFile);
+		free(ConnectionFile);
+		if (!rc)
+			return FALSE;
+	}
+
+	if (setDefaultConnectionType)
+	{
+		if (!freerdp_set_connection_type(settings, CONNECTION_TYPE_AUTODETECT))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static rdpFileLine* freerdp_client_rdp_file_find_line_by_name(const rdpFile* file, const char* name)
+{
+	BOOL bFound = FALSE;
+	rdpFileLine* line = NULL;
+
+	for (size_t index = 0; index < file->lineCount; index++)
+	{
+		line = &(file->lines[index]);
+
+		if (line->flags & RDP_FILE_LINE_FLAG_FORMATTED)
+		{
+			if (_stricmp(name, line->name) == 0)
+			{
+				bFound = TRUE;
+				break;
+			}
+		}
+	}
+
+	return (bFound) ? line : NULL;
+}
+/**
+ * Set a string option to a rdpFile
+ * @param file rdpFile
+ * @param name name of the option
+ * @param value value of the option
+ * @return 0 on success
+ */
+int freerdp_client_rdp_file_set_string_option(rdpFile* file, const char* name, const char* value)
+{
+	return freerdp_client_rdp_file_set_string(file, name, value);
+}
+
+const char* freerdp_client_rdp_file_get_string_option(const rdpFile* file, const char* name)
+{
+	LPSTR* value = NULL;
+	rdpFileLine* line = NULL;
+
+	if (freerdp_client_rdp_file_find_string_entry((rdpFile*)file, name, &value, &line))
+	{
+		if (value && ~(size_t)(*value))
+			return *value;
+		if (line)
+			return line->sValue;
+	}
+
+	return NULL;
+}
+
+int freerdp_client_rdp_file_set_integer_option(rdpFile* file, const char* name, int value)
+{
+	return freerdp_client_rdp_file_set_integer(file, name, value);
+}
+
+int freerdp_client_rdp_file_get_integer_option(const rdpFile* file, const char* name)
+{
+	DWORD* value = NULL;
+	rdpFileLine* line = NULL;
+
+	if (freerdp_client_rdp_file_find_integer_entry((rdpFile*)file, name, &value, &line))
+	{
+		if (value && ~(*value))
+			return *value;
+		if (line)
+			return (int)line->iValue;
+	}
+
+	return -1;
+}
+
+static void freerdp_client_file_string_check_free(LPSTR str)
+{
+	if (~((size_t)str))
+		free(str);
+}
+
+rdpFile* freerdp_client_rdp_file_new(void)
+{
+	return freerdp_client_rdp_file_new_ex(0);
+}
+
+rdpFile* freerdp_client_rdp_file_new_ex(DWORD flags)
+{
+	rdpFile* file = (rdpFile*)calloc(1, sizeof(rdpFile));
+
+	if (!file)
+		return NULL;
+
+	file->flags = flags;
+
+	FillMemory(file, sizeof(rdpFile), 0xFF);
+	file->lines = NULL;
+	file->lineCount = 0;
+	file->lineSize = 32;
+	file->GatewayProfileUsageMethod = 1;
+	file->lines = (rdpFileLine*)calloc(file->lineSize, sizeof(rdpFileLine));
+
+	file->args = freerdp_addin_argv_new(0, NULL);
+	if (!file->lines || !file->args)
+		goto fail;
+
+	if (!freerdp_client_add_option(file, "freerdp"))
+		goto fail;
+
+	return file;
+fail:
+	WINPR_PRAGMA_DIAG_PUSH
+	WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
+	freerdp_client_rdp_file_free(file);
+	WINPR_PRAGMA_DIAG_POP
+	return NULL;
+}
+void freerdp_client_rdp_file_free(rdpFile* file)
+{
+	if (file)
+	{
+		if (file->lineCount)
+		{
+			for (size_t i = 0; i < file->lineCount; i++)
+			{
+				free(file->lines[i].name);
+				free(file->lines[i].sValue);
+			}
+		}
+		free(file->lines);
+
+		freerdp_addin_argv_free(file->args);
+
+		freerdp_client_file_string_check_free(file->Username);
+		freerdp_client_file_string_check_free(file->Domain);
+		freerdp_client_file_string_check_free(file->Password);
+		freerdp_client_file_string_check_free(file->FullAddress);
+		freerdp_client_file_string_check_free(file->AlternateFullAddress);
+		freerdp_client_file_string_check_free(file->UsbDevicesToRedirect);
+		freerdp_client_file_string_check_free(file->RedirectCameras);
+		freerdp_client_file_string_check_free(file->SelectedMonitors);
+		freerdp_client_file_string_check_free(file->LoadBalanceInfo);
+		freerdp_client_file_string_check_free(file->RemoteApplicationName);
+		freerdp_client_file_string_check_free(file->RemoteApplicationIcon);
+		freerdp_client_file_string_check_free(file->RemoteApplicationProgram);
+		freerdp_client_file_string_check_free(file->RemoteApplicationFile);
+		freerdp_client_file_string_check_free(file->RemoteApplicationGuid);
+		freerdp_client_file_string_check_free(file->RemoteApplicationCmdLine);
+		freerdp_client_file_string_check_free(file->AlternateShell);
+		freerdp_client_file_string_check_free(file->ShellWorkingDirectory);
+		freerdp_client_file_string_check_free(file->GatewayHostname);
+		freerdp_client_file_string_check_free(file->GatewayAccessToken);
+		freerdp_client_file_string_check_free(file->KdcProxyName);
+		freerdp_client_file_string_check_free(file->DrivesToRedirect);
+		freerdp_client_file_string_check_free(file->DevicesToRedirect);
+		freerdp_client_file_string_check_free(file->WinPosStr);
+		freerdp_client_file_string_check_free(file->ResourceProvider);
+		freerdp_client_file_string_check_free(file->WvdEndpointPool);
+		freerdp_client_file_string_check_free(file->geo);
+		freerdp_client_file_string_check_free(file->armpath);
+		freerdp_client_file_string_check_free(file->aadtenantid);
+		freerdp_client_file_string_check_free(file->diagnosticserviceurl);
+		freerdp_client_file_string_check_free(file->hubdiscoverygeourl);
+		freerdp_client_file_string_check_free(file->activityhint);
+		free(file);
+	}
+}
+
+void freerdp_client_rdp_file_set_callback_context(rdpFile* file, void* context)
+{
+	file->context = context;
+}