diff --git a/CMakeLists.txt b/CMakeLists.txt index b6ecb116f..6bf9bb05d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -347,6 +347,12 @@ if(NOT IOS) find_package(Threads REQUIRED) endif() +if (IOS) + set(HAVE_STRNDUP 1) +else() + CHECK_SYMBOL_EXISTS(strndup string.h HAVE_STRNDUP) +endif() + if(NOT WIN32) CHECK_SYMBOL_EXISTS(pthread_mutex_timedlock pthread.h HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL) if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL) diff --git a/config.h.in b/config.h.in index 2264e5952..ec05d38d8 100644 --- a/config.h.in +++ b/config.h.in @@ -25,6 +25,7 @@ #cmakedefine HAVE_VALGRIND_MEMCHECK_H #cmakedefine HAVE_EXECINFO_H #cmakedefine HAVE_GETLOGIN_R +#cmakedefine HAVE_STRNDUP /* Features */ #cmakedefine SWRESAMPLE_FOUND diff --git a/include/freerdp/settings.h b/include/freerdp/settings.h index 4591b5567..22c8b2c53 100644 --- a/include/freerdp/settings.h +++ b/include/freerdp/settings.h @@ -504,7 +504,6 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL; /* ThreadingFlags */ #define THREADING_FLAGS_DISABLE_THREADS 0x00000001 - /* Settings */ #ifdef __GNUC__ @@ -536,6 +535,7 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL; #define FreeRDP_MaxTimeInCheckLoop (26) #define FreeRDP_AcceptedCert (27) #define FreeRDP_AcceptedCertLength (28) +#define FreeRDP_ThreadingFlags (64) #define FreeRDP_RdpVersion (128) #define FreeRDP_DesktopWidth (129) #define FreeRDP_DesktopHeight (130) @@ -895,6 +895,8 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL; #define FreeRDP_TcpKeepAliveDelay (5192) #define FreeRDP_TcpKeepAliveInterval (5193) #define FreeRDP_TcpAckTimeout (5194) +#define FreeRDP_ActionScript (5195) +#define FreeRDP_Floatbar (5196) /** * FreeRDP Settings Data Structure @@ -928,9 +930,7 @@ struct rdp_settings ALIGN64 UINT32 MaxTimeInCheckLoop; /* 26 */ ALIGN64 char* AcceptedCert; /* 27 */ ALIGN64 UINT32 AcceptedCertLength; /* 28 */ - - UINT64 padding0064[64 - 29]; /* 29 */ - + UINT64 padding0064[64 - 29]; /* 29 */ /* resource management related options */ ALIGN64 UINT32 ThreadingFlags; /* 64 */ @@ -1551,7 +1551,9 @@ struct rdp_settings ALIGN64 UINT32 TcpKeepAliveDelay; /* 5192 */ ALIGN64 UINT32 TcpKeepAliveInterval; /* 5193 */ ALIGN64 UINT32 TcpAckTimeout; /* 5194 */ - UINT64 padding5312[5312 - 5195]; /* 5195 */ + ALIGN64 char* ActionScript; /* 5195 */ + ALIGN64 UINT32 Floatbar; /* 5196 */ + UINT64 padding5312[5312 - 5197]; /* 5197 */ /** * WARNING: End of ABI stable zone! @@ -1570,9 +1572,6 @@ struct rdp_settings ALIGN64 BYTE* SettingsModified; /* byte array marking fields that have been modified from their default value - currently UNUSED! */ - ALIGN64 char* ActionScript; - ALIGN64 DWORD Floatbar; - ALIGN64 char* XSelectionAtom; }; typedef struct rdp_settings rdpSettings; @@ -1696,10 +1695,24 @@ extern "C" FREERDP_API BOOL freerdp_settings_set_uint64(rdpSettings* settings, size_t id, UINT64 param); FREERDP_API const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id); + FREERDP_API BOOL freerdp_settings_set_string_len(rdpSettings* settings, size_t id, + const char* param, size_t len); FREERDP_API BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* param); FREERDP_API const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id); + FREERDP_API void* freerdp_settings_get_pointer_writable(const rdpSettings* settings, size_t id); + FREERDP_API BOOL freerdp_settings_set_pointer(rdpSettings* settings, size_t id, + const void* data); + FREERDP_API BOOL freerdp_settings_set_pointer_len(rdpSettings* settings, size_t id, + const void* data, size_t len); + + FREERDP_API const void* freerdp_settings_get_pointer_array(const rdpSettings* settings, + size_t id, size_t offset); + FREERDP_API void* freerdp_settings_get_pointer_array_writable(const rdpSettings* settings, + size_t id, size_t offset); + FREERDP_API BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, size_t id, + size_t offset, const void* data); FREERDP_API BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name, const char* value); diff --git a/libfreerdp/common/settings.c b/libfreerdp/common/settings.c index 882945ff2..6877bbdde 100644 --- a/libfreerdp/common/settings.c +++ b/libfreerdp/common/settings.c @@ -29,6 +29,8 @@ #include +#include "../core/settings.h" +#include "../core/certificate.h" #include #include #include @@ -182,11 +184,12 @@ BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device) if (!settings->DeviceArray) return FALSE; - if (settings->DeviceArraySize < (settings->DeviceCount + 1)) + if (freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize) < + (settings->DeviceCount + 1)) { UINT32 new_size; RDPDR_DEVICE** new_array; - new_size = settings->DeviceArraySize * 2; + new_size = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize) * 2; new_array = (RDPDR_DEVICE**)realloc(settings->DeviceArray, new_size * sizeof(RDPDR_DEVICE*)); @@ -194,7 +197,8 @@ BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device) return FALSE; settings->DeviceArray = new_array; - settings->DeviceArraySize = new_size; + if (!freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, new_size)) + return FALSE; } settings->DeviceArray[settings->DeviceCount++] = device; @@ -448,21 +452,23 @@ void freerdp_device_collection_free(rdpSettings* settings) } free(settings->DeviceArray); - settings->DeviceArraySize = 0; + freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, 0); settings->DeviceArray = NULL; settings->DeviceCount = 0; } BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel) { + UINT32 count; if (!settings->StaticChannelArray) return FALSE; - if (settings->StaticChannelArraySize < (settings->StaticChannelCount + 1)) + if (freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize) < + (freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount) + 1)) { UINT32 new_size; ADDIN_ARGV** new_array; - new_size = settings->StaticChannelArraySize * 2; + new_size = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize) * 2; new_array = (ADDIN_ARGV**)realloc(settings->StaticChannelArray, new_size * sizeof(ADDIN_ARGV*)); @@ -470,11 +476,13 @@ BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* ch return FALSE; settings->StaticChannelArray = new_array; - settings->StaticChannelArraySize = new_size; + if (!freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, new_size)) + return FALSE; } - settings->StaticChannelArray[settings->StaticChannelCount++] = channel; - return TRUE; + count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount); + settings->StaticChannelArray[count++] = channel; + return freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, count); } ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const char* name) @@ -482,7 +490,8 @@ ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const UINT32 index; ADDIN_ARGV* channel; - for (index = 0; index < settings->StaticChannelCount; index++) + for (index = 0; index < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount); + index++) { channel = settings->StaticChannelArray[index]; @@ -532,7 +541,7 @@ void freerdp_static_channel_collection_free(rdpSettings* settings) int j; UINT32 i; - for (i = 0; i < settings->StaticChannelCount; i++) + for (i = 0; i < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount); i++) { if (!settings->StaticChannelArray[i]) continue; @@ -545,31 +554,36 @@ void freerdp_static_channel_collection_free(rdpSettings* settings) } free(settings->StaticChannelArray); - settings->StaticChannelArraySize = 0; + freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, 0); settings->StaticChannelArray = NULL; - settings->StaticChannelCount = 0; + freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, 0); } BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel) { + UINT32 count; if (!settings->DynamicChannelArray) return FALSE; - if (settings->DynamicChannelArraySize < (settings->DynamicChannelCount + 1)) + if (freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize) < + (freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount) + 1)) { ADDIN_ARGV** new_array; - new_array = realloc(settings->DynamicChannelArray, - settings->DynamicChannelArraySize * sizeof(ADDIN_ARGV*) * 2); + const size_t size = + freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize) * 2; + new_array = realloc(settings->DynamicChannelArray, sizeof(ADDIN_ARGV*) * size); if (!new_array) return FALSE; - settings->DynamicChannelArraySize *= 2; settings->DynamicChannelArray = new_array; + if (!freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, size)) + return FALSE; } - settings->DynamicChannelArray[settings->DynamicChannelCount++] = channel; - return TRUE; + count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); + settings->DynamicChannelArray[count++] = channel; + return freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, count); } ADDIN_ARGV* freerdp_dynamic_channel_collection_find(rdpSettings* settings, const char* name) @@ -577,7 +591,8 @@ ADDIN_ARGV* freerdp_dynamic_channel_collection_find(rdpSettings* settings, const UINT32 index; ADDIN_ARGV* channel; - for (index = 0; index < settings->DynamicChannelCount; index++) + for (index = 0; index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); + index++) { channel = settings->DynamicChannelArray[index]; @@ -627,7 +642,7 @@ void freerdp_dynamic_channel_collection_free(rdpSettings* settings) int j; UINT32 i; - for (i = 0; i < settings->DynamicChannelCount; i++) + for (i = 0; i < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); i++) { if (!settings->DynamicChannelArray[i]) continue; @@ -640,9 +655,9 @@ void freerdp_dynamic_channel_collection_free(rdpSettings* settings) } free(settings->DynamicChannelArray); - settings->DynamicChannelArraySize = 0; + freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, 0); settings->DynamicChannelArray = NULL; - settings->DynamicChannelCount = 0; + freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, 0); } void freerdp_target_net_addresses_free(rdpSettings* settings) @@ -661,40 +676,60 @@ void freerdp_target_net_addresses_free(rdpSettings* settings) void freerdp_performance_flags_make(rdpSettings* settings) { - settings->PerformanceFlags = PERF_FLAG_NONE; + UINT32 PerformanceFlags = PERF_FLAG_NONE; - if (settings->AllowFontSmoothing) - settings->PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING; + if (freerdp_settings_get_bool(settings, FreeRDP_AllowFontSmoothing)) + PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING; - if (settings->AllowDesktopComposition) - settings->PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION; + if (freerdp_settings_get_bool(settings, FreeRDP_AllowDesktopComposition)) + PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION; - if (settings->DisableWallpaper) - settings->PerformanceFlags |= PERF_DISABLE_WALLPAPER; + if (freerdp_settings_get_bool(settings, FreeRDP_DisableWallpaper)) + PerformanceFlags |= PERF_DISABLE_WALLPAPER; - if (settings->DisableFullWindowDrag) - settings->PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG; + if (freerdp_settings_get_bool(settings, FreeRDP_DisableFullWindowDrag)) + PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG; - if (settings->DisableMenuAnims) - settings->PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS; + if (freerdp_settings_get_bool(settings, FreeRDP_DisableMenuAnims)) + PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS; - if (settings->DisableThemes) - settings->PerformanceFlags |= PERF_DISABLE_THEMING; + if (freerdp_settings_get_bool(settings, FreeRDP_DisableThemes)) + PerformanceFlags |= PERF_DISABLE_THEMING; + freerdp_settings_set_uint32(settings, FreeRDP_PerformanceFlags, PerformanceFlags); } void freerdp_performance_flags_split(rdpSettings* settings) { - settings->AllowFontSmoothing = - (settings->PerformanceFlags & PERF_ENABLE_FONT_SMOOTHING) ? TRUE : FALSE; - settings->AllowDesktopComposition = - (settings->PerformanceFlags & PERF_ENABLE_DESKTOP_COMPOSITION) ? TRUE : FALSE; - settings->DisableWallpaper = - (settings->PerformanceFlags & PERF_DISABLE_WALLPAPER) ? TRUE : FALSE; - settings->DisableFullWindowDrag = - (settings->PerformanceFlags & PERF_DISABLE_FULLWINDOWDRAG) ? TRUE : FALSE; - settings->DisableMenuAnims = - (settings->PerformanceFlags & PERF_DISABLE_MENUANIMATIONS) ? TRUE : FALSE; - settings->DisableThemes = (settings->PerformanceFlags & PERF_DISABLE_THEMING) ? TRUE : FALSE; + freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & + PERF_ENABLE_FONT_SMOOTHING) + ? TRUE + : FALSE); + freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & + PERF_ENABLE_DESKTOP_COMPOSITION) + ? TRUE + : FALSE); + freerdp_settings_set_bool( + settings, FreeRDP_DisableWallpaper, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_WALLPAPER) + ? TRUE + : FALSE); + freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & + PERF_DISABLE_FULLWINDOWDRAG) + ? TRUE + : FALSE); + freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & + PERF_DISABLE_MENUANIMATIONS) + ? TRUE + : FALSE); + freerdp_settings_set_bool( + settings, FreeRDP_DisableThemes, + (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_THEMING) + ? TRUE + : FALSE); } BOOL freerdp_set_gateway_usage_method(rdpSettings* settings, UINT32 GatewayUsageMethod) @@ -926,6 +961,241 @@ BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name return FALSE; } +static BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, size_t id, SSIZE_T lenId, + const void* data, size_t len) +{ + BOOL rc; + void* copy; + void* old = freerdp_settings_get_pointer_writable(settings, id); + free(old); + if (!freerdp_settings_set_pointer(settings, id, NULL)) + return FALSE; + if (lenId >= 0) + { + if (!freerdp_settings_set_uint32(settings, lenId, 0)) + return FALSE; + } + + if (len == 0) + return TRUE; + copy = calloc(len, 1); + if (!copy) + return FALSE; + if (data) + memcpy(copy, data, len); + rc = freerdp_settings_set_pointer(settings, id, copy); + if (!rc) + { + free(copy); + return FALSE; + } + if (lenId < 0) + return TRUE; + return freerdp_settings_set_uint32(settings, lenId, len); +} + +const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id) +{ + return freerdp_settings_get_pointer_writable(settings, id); +} + +BOOL freerdp_settings_set_pointer_len(rdpSettings* settings, size_t id, const void* data, + size_t len) +{ + if (!settings) + return FALSE; + + switch (id) + { + case FreeRDP_RdpServerCertificate: + certificate_free(settings->RdpServerCertificate); + settings->RdpServerCertificate = data; + return TRUE; + case FreeRDP_RdpServerRsaKey: + key_free(settings->RdpServerRsaKey); + settings->RdpServerRsaKey = (rdpRsaKey*)data; + return TRUE; + case FreeRDP_RedirectionPassword: + return freerdp_settings_set_pointer_len_(settings, id, + FreeRDP_RedirectionPasswordLength, data, len); + case FreeRDP_RedirectionTsvUrl: + return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_RedirectionTsvUrlLength, + data, len); + case FreeRDP_LoadBalanceInfo: + return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_LoadBalanceInfoLength, + data, len); + case FreeRDP_ServerRandom: + return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerRandomLength, data, + len); + case FreeRDP_ClientRandom: + return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ClientRandomLength, data, + len); + case FreeRDP_ServerCertificate: + return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerCertificateLength, + data, len); + case FreeRDP_TargetNetAddresses: + if (data == NULL) + { + freerdp_target_net_addresses_free(settings); + if (!freerdp_settings_set_uint32(settings, FreeRDP_TargetNetAddressCount, len)) + return FALSE; + } + return freerdp_settings_set_pointer_len_(settings, FreeRDP_TargetNetAddresses, + FreeRDP_TargetNetAddressCount, data, len); + + case FreeRDP_TargetNetPorts: + if (data == NULL) + { + freerdp_target_net_addresses_free(settings); + if (!freerdp_settings_set_uint32(settings, FreeRDP_TargetNetAddressCount, len)) + return FALSE; + } + return freerdp_settings_set_pointer_len_(settings, FreeRDP_TargetNetPorts, + FreeRDP_TargetNetAddressCount, data, len); + case FreeRDP_ClientAutoReconnectCookie: + case FreeRDP_ServerAutoReconnectCookie: + case FreeRDP_ChannelDefArray: + case FreeRDP_MonitorDefArray: + case FreeRDP_MonitorIds: + case FreeRDP_ReceivedCapabilities: + case FreeRDP_OrderSupport: + case FreeRDP_ClientTimeZone: + case FreeRDP_BitmapCacheV2CellInfo: + case FreeRDP_GlyphCache: + case FreeRDP_FragCache: + return freerdp_settings_set_pointer_len_(settings, id, -1, data, len); + default: + if ((data == NULL) && (len == 0)) + { + freerdp_settings_set_pointer(settings, id, NULL); + } + else + WLog_WARN(TAG, "Invalid id %" PRIuz " for %s", id, __FUNCTION__); + return FALSE; + } +} + +void* freerdp_settings_get_pointer_array_writable(const rdpSettings* settings, size_t id, + size_t offset) +{ + if (!settings) + return NULL; + switch (id) + { + case FreeRDP_OrderSupport: + if (offset >= 32) + return FALSE; + return &settings->OrderSupport[offset]; + case FreeRDP_MonitorIds: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds)) + return NULL; + return &settings->MonitorIds[offset]; + case FreeRDP_MonitorDefArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize)) + return NULL; + return &settings->MonitorDefArray[offset]; + + case FreeRDP_ChannelDefArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize)) + return NULL; + return &settings->ChannelDefArray[offset]; + case FreeRDP_DeviceArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize)) + return NULL; + return &settings->DeviceArray[offset]; + case FreeRDP_StaticChannelArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize)) + return NULL; + return settings->StaticChannelArray[offset]; + case FreeRDP_DynamicChannelArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize)) + return NULL; + return settings->DynamicChannelArray[offset]; + case FreeRDP_FragCache: + if (offset >= 1) + return NULL; + return &settings->FragCache[offset]; + case FreeRDP_GlyphCache: + if (offset >= 10) + return NULL; + return &settings->GlyphCache[offset]; + case FreeRDP_BitmapCacheV2CellInfo: + /* TODO: BitmapCacheV2NumCells should be limited to 4 + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells)) + return NULL; + */ + + return &settings->BitmapCacheV2CellInfo[offset]; + case FreeRDP_ReceivedCapabilities: + if (offset > settings->ReceivedCapabilitiesSize) + return 0; + return &settings->ReceivedCapabilities[offset]; + default: + WLog_WARN(TAG, "Invalid id %" PRIuz " for %s", id, __FUNCTION__); + return NULL; + } +} + +BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, size_t id, size_t offset, + const void* data) +{ + if (!settings) + return FALSE; + switch (id) + { + case FreeRDP_TargetNetAddresses: + if ((offset >= settings->TargetNetAddressCount) || !data) + return FALSE; + free(settings->TargetNetAddresses[offset]); + settings->TargetNetAddresses[offset] = _strdup((const char*)data); + return settings->TargetNetAddresses[offset] != NULL; + case FreeRDP_TargetNetPorts: + if ((offset >= settings->TargetNetAddressCount) || !data) + return FALSE; + settings->TargetNetPorts[offset] = *((const UINT32*)data); + return TRUE; + case FreeRDP_BitmapCacheV2CellInfo: + if ((offset > 5) || !data) + return FALSE; + settings->BitmapCacheV2CellInfo[offset] = *(const BITMAP_CACHE_V2_CELL_INFO*)data; + return TRUE; + case FreeRDP_OrderSupport: + if ((offset >= 32) || !data) + return FALSE; + settings->OrderSupport[offset] = *(const BOOL*)data; + return TRUE; + case FreeRDP_GlyphCache: + if ((offset >= 10) || !data) + return FALSE; + settings->GlyphCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data; + return TRUE; + case FreeRDP_FragCache: + if ((offset >= 1) || !data) + return FALSE; + settings->FragCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data; + return TRUE; + case FreeRDP_MonitorIds: + if ((offset > freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds)) || !data) + return FALSE; + settings->MonitorIds[offset] = *(const UINT32*)data; + return TRUE; + case FreeRDP_ChannelDefArray: + if (offset > freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize)) + return FALSE; + settings->ChannelDefArray[offset] = *(const CHANNEL_DEF*)data; + return TRUE; + default: + WLog_WARN(TAG, "Invalid id %" PRIuz " for %s", id, __FUNCTION__); + return FALSE; + } +} + +const void* freerdp_settings_get_pointer_array(const rdpSettings* settings, size_t id, + size_t offset) +{ + return freerdp_settings_get_pointer_array_writable(settings, id, offset); +} + UINT32 freerdp_settings_get_codecs_flags(const rdpSettings* settings) { UINT32 flags = FREERDP_CODEC_ALL; @@ -939,4 +1209,4 @@ UINT32 freerdp_settings_get_codecs_flags(const rdpSettings* settings) } /*TODO: check other codecs flags */ return flags; -} \ No newline at end of file +} diff --git a/libfreerdp/common/settings_getters.c b/libfreerdp/common/settings_getters.c index 83711713a..cb8b9395a 100644 --- a/libfreerdp/common/settings_getters.c +++ b/libfreerdp/common/settings_getters.c @@ -3,6 +3,8 @@ #include #include +#include "../core/settings.h" + #define TAG FREERDP_TAG("common.settings") BOOL freerdp_settings_get_bool(const rdpSettings* settings, size_t id) @@ -1360,6 +1362,9 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id) case FreeRDP_ExtEncryptionMethods: return settings->ExtEncryptionMethods; + case FreeRDP_Floatbar: + return settings->Floatbar; + case FreeRDP_FrameAcknowledge: return settings->FrameAcknowledge; @@ -1579,6 +1584,9 @@ UINT32 freerdp_settings_get_uint32(const rdpSettings* settings, size_t id) case FreeRDP_TcpKeepAliveRetries: return settings->TcpKeepAliveRetries; + case FreeRDP_ThreadingFlags: + return settings->ThreadingFlags; + case FreeRDP_TlsSecLevel: return settings->TlsSecLevel; @@ -1741,6 +1749,10 @@ BOOL freerdp_settings_set_uint32(rdpSettings* settings, size_t id, UINT32 val) settings->ExtEncryptionMethods = val; break; + case FreeRDP_Floatbar: + settings->Floatbar = val; + break; + case FreeRDP_FrameAcknowledge: settings->FrameAcknowledge = val; break; @@ -2033,6 +2045,10 @@ BOOL freerdp_settings_set_uint32(rdpSettings* settings, size_t id, UINT32 val) settings->TcpKeepAliveRetries = val; break; + case FreeRDP_ThreadingFlags: + settings->ThreadingFlags = val; + break; + case FreeRDP_TlsSecLevel: settings->TlsSecLevel = val; break; @@ -2164,6 +2180,9 @@ const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id) case FreeRDP_AcceptedCert: return settings->AcceptedCert; + case FreeRDP_ActionScript: + return settings->ActionScript; + case FreeRDP_AllowedTlsCiphers: return settings->AllowedTlsCiphers; @@ -2368,7 +2387,8 @@ const char* freerdp_settings_get_string(const rdpSettings* settings, size_t id) } } -BOOL freerdp_settings_set_string_(rdpSettings* settings, size_t id, const char* val, BOOL cleanup) +BOOL freerdp_settings_set_string_(rdpSettings* settings, size_t id, const char* val, size_t len, + BOOL cleanup) { if (!settings) return FALSE; @@ -2378,403 +2398,409 @@ BOOL freerdp_settings_set_string_(rdpSettings* settings, size_t id, const char* case FreeRDP_AcceptedCert: if (cleanup) free(settings->AcceptedCert); - settings->AcceptedCert = (val ? _strdup(val) : NULL); + settings->AcceptedCert = (val ? strndup(val, len) : NULL); return (!val || settings->AcceptedCert != NULL); + case FreeRDP_ActionScript: + if (cleanup) + free(settings->ActionScript); + settings->ActionScript = (val ? strndup(val, len) : NULL); + return (!val || settings->ActionScript != NULL); + case FreeRDP_AllowedTlsCiphers: if (cleanup) free(settings->AllowedTlsCiphers); - settings->AllowedTlsCiphers = (val ? _strdup(val) : NULL); + settings->AllowedTlsCiphers = (val ? strndup(val, len) : NULL); return (!val || settings->AllowedTlsCiphers != NULL); case FreeRDP_AlternateShell: if (cleanup) free(settings->AlternateShell); - settings->AlternateShell = (val ? _strdup(val) : NULL); + settings->AlternateShell = (val ? strndup(val, len) : NULL); return (!val || settings->AlternateShell != NULL); case FreeRDP_AssistanceFile: if (cleanup) free(settings->AssistanceFile); - settings->AssistanceFile = (val ? _strdup(val) : NULL); + settings->AssistanceFile = (val ? strndup(val, len) : NULL); return (!val || settings->AssistanceFile != NULL); case FreeRDP_AuthenticationServiceClass: if (cleanup) free(settings->AuthenticationServiceClass); - settings->AuthenticationServiceClass = (val ? _strdup(val) : NULL); + settings->AuthenticationServiceClass = (val ? strndup(val, len) : NULL); return (!val || settings->AuthenticationServiceClass != NULL); case FreeRDP_CertificateAcceptedFingerprints: if (cleanup) free(settings->CertificateAcceptedFingerprints); - settings->CertificateAcceptedFingerprints = (val ? _strdup(val) : NULL); + settings->CertificateAcceptedFingerprints = (val ? strndup(val, len) : NULL); return (!val || settings->CertificateAcceptedFingerprints != NULL); case FreeRDP_CertificateContent: if (cleanup) free(settings->CertificateContent); - settings->CertificateContent = (val ? _strdup(val) : NULL); + settings->CertificateContent = (val ? strndup(val, len) : NULL); return (!val || settings->CertificateContent != NULL); case FreeRDP_CertificateFile: if (cleanup) free(settings->CertificateFile); - settings->CertificateFile = (val ? _strdup(val) : NULL); + settings->CertificateFile = (val ? strndup(val, len) : NULL); return (!val || settings->CertificateFile != NULL); case FreeRDP_CertificateName: if (cleanup) free(settings->CertificateName); - settings->CertificateName = (val ? _strdup(val) : NULL); + settings->CertificateName = (val ? strndup(val, len) : NULL); return (!val || settings->CertificateName != NULL); case FreeRDP_ClientAddress: if (cleanup) free(settings->ClientAddress); - settings->ClientAddress = (val ? _strdup(val) : NULL); + settings->ClientAddress = (val ? strndup(val, len) : NULL); return (!val || settings->ClientAddress != NULL); case FreeRDP_ClientDir: if (cleanup) free(settings->ClientDir); - settings->ClientDir = (val ? _strdup(val) : NULL); + settings->ClientDir = (val ? strndup(val, len) : NULL); return (!val || settings->ClientDir != NULL); case FreeRDP_ClientHostname: if (cleanup) free(settings->ClientHostname); - settings->ClientHostname = (val ? _strdup(val) : NULL); + settings->ClientHostname = (val ? strndup(val, len) : NULL); return (!val || settings->ClientHostname != NULL); case FreeRDP_ClientProductId: if (cleanup) free(settings->ClientProductId); - settings->ClientProductId = (val ? _strdup(val) : NULL); + settings->ClientProductId = (val ? strndup(val, len) : NULL); return (!val || settings->ClientProductId != NULL); case FreeRDP_ComputerName: if (cleanup) free(settings->ComputerName); - settings->ComputerName = (val ? _strdup(val) : NULL); + settings->ComputerName = (val ? strndup(val, len) : NULL); return (!val || settings->ComputerName != NULL); case FreeRDP_ConfigPath: if (cleanup) free(settings->ConfigPath); - settings->ConfigPath = (val ? _strdup(val) : NULL); + settings->ConfigPath = (val ? strndup(val, len) : NULL); return (!val || settings->ConfigPath != NULL); case FreeRDP_ConnectionFile: if (cleanup) free(settings->ConnectionFile); - settings->ConnectionFile = (val ? _strdup(val) : NULL); + settings->ConnectionFile = (val ? strndup(val, len) : NULL); return (!val || settings->ConnectionFile != NULL); case FreeRDP_CurrentPath: if (cleanup) free(settings->CurrentPath); - settings->CurrentPath = (val ? _strdup(val) : NULL); + settings->CurrentPath = (val ? strndup(val, len) : NULL); return (!val || settings->CurrentPath != NULL); case FreeRDP_Domain: if (cleanup) free(settings->Domain); - settings->Domain = (val ? _strdup(val) : NULL); + settings->Domain = (val ? strndup(val, len) : NULL); return (!val || settings->Domain != NULL); case FreeRDP_DrivesToRedirect: if (cleanup) free(settings->DrivesToRedirect); - settings->DrivesToRedirect = (val ? _strdup(val) : NULL); + settings->DrivesToRedirect = (val ? strndup(val, len) : NULL); return (!val || settings->DrivesToRedirect != NULL); case FreeRDP_DumpRemoteFxFile: if (cleanup) free(settings->DumpRemoteFxFile); - settings->DumpRemoteFxFile = (val ? _strdup(val) : NULL); + settings->DumpRemoteFxFile = (val ? strndup(val, len) : NULL); return (!val || settings->DumpRemoteFxFile != NULL); case FreeRDP_DynamicDSTTimeZoneKeyName: if (cleanup) free(settings->DynamicDSTTimeZoneKeyName); - settings->DynamicDSTTimeZoneKeyName = (val ? _strdup(val) : NULL); + settings->DynamicDSTTimeZoneKeyName = (val ? strndup(val, len) : NULL); return (!val || settings->DynamicDSTTimeZoneKeyName != NULL); case FreeRDP_GatewayAcceptedCert: if (cleanup) free(settings->GatewayAcceptedCert); - settings->GatewayAcceptedCert = (val ? _strdup(val) : NULL); + settings->GatewayAcceptedCert = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayAcceptedCert != NULL); case FreeRDP_GatewayAccessToken: if (cleanup) free(settings->GatewayAccessToken); - settings->GatewayAccessToken = (val ? _strdup(val) : NULL); + settings->GatewayAccessToken = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayAccessToken != NULL); case FreeRDP_GatewayDomain: if (cleanup) free(settings->GatewayDomain); - settings->GatewayDomain = (val ? _strdup(val) : NULL); + settings->GatewayDomain = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayDomain != NULL); case FreeRDP_GatewayHostname: if (cleanup) free(settings->GatewayHostname); - settings->GatewayHostname = (val ? _strdup(val) : NULL); + settings->GatewayHostname = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayHostname != NULL); case FreeRDP_GatewayPassword: if (cleanup) free(settings->GatewayPassword); - settings->GatewayPassword = (val ? _strdup(val) : NULL); + settings->GatewayPassword = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayPassword != NULL); case FreeRDP_GatewayUsername: if (cleanup) free(settings->GatewayUsername); - settings->GatewayUsername = (val ? _strdup(val) : NULL); + settings->GatewayUsername = (val ? strndup(val, len) : NULL); return (!val || settings->GatewayUsername != NULL); case FreeRDP_HomePath: if (cleanup) free(settings->HomePath); - settings->HomePath = (val ? _strdup(val) : NULL); + settings->HomePath = (val ? strndup(val, len) : NULL); return (!val || settings->HomePath != NULL); case FreeRDP_ImeFileName: if (cleanup) free(settings->ImeFileName); - settings->ImeFileName = (val ? _strdup(val) : NULL); + settings->ImeFileName = (val ? strndup(val, len) : NULL); return (!val || settings->ImeFileName != NULL); case FreeRDP_KerberosKdc: if (cleanup) free(settings->KerberosKdc); - settings->KerberosKdc = (val ? _strdup(val) : NULL); + settings->KerberosKdc = (val ? strndup(val, len) : NULL); return (!val || settings->KerberosKdc != NULL); case FreeRDP_KerberosRealm: if (cleanup) free(settings->KerberosRealm); - settings->KerberosRealm = (val ? _strdup(val) : NULL); + settings->KerberosRealm = (val ? strndup(val, len) : NULL); return (!val || settings->KerberosRealm != NULL); case FreeRDP_KeyboardRemappingList: if (cleanup) free(settings->KeyboardRemappingList); - settings->KeyboardRemappingList = (val ? _strdup(val) : NULL); + settings->KeyboardRemappingList = (val ? strndup(val, len) : NULL); return (!val || settings->KeyboardRemappingList != NULL); case FreeRDP_NtlmSamFile: if (cleanup) free(settings->NtlmSamFile); - settings->NtlmSamFile = (val ? _strdup(val) : NULL); + settings->NtlmSamFile = (val ? strndup(val, len) : NULL); return (!val || settings->NtlmSamFile != NULL); case FreeRDP_Password: if (cleanup) free(settings->Password); - settings->Password = (val ? _strdup(val) : NULL); + settings->Password = (val ? strndup(val, len) : NULL); return (!val || settings->Password != NULL); case FreeRDP_PasswordHash: if (cleanup) free(settings->PasswordHash); - settings->PasswordHash = (val ? _strdup(val) : NULL); + settings->PasswordHash = (val ? strndup(val, len) : NULL); return (!val || settings->PasswordHash != NULL); case FreeRDP_PlayRemoteFxFile: if (cleanup) free(settings->PlayRemoteFxFile); - settings->PlayRemoteFxFile = (val ? _strdup(val) : NULL); + settings->PlayRemoteFxFile = (val ? strndup(val, len) : NULL); return (!val || settings->PlayRemoteFxFile != NULL); case FreeRDP_PreconnectionBlob: if (cleanup) free(settings->PreconnectionBlob); - settings->PreconnectionBlob = (val ? _strdup(val) : NULL); + settings->PreconnectionBlob = (val ? strndup(val, len) : NULL); return (!val || settings->PreconnectionBlob != NULL); case FreeRDP_PrivateKeyContent: if (cleanup) free(settings->PrivateKeyContent); - settings->PrivateKeyContent = (val ? _strdup(val) : NULL); + settings->PrivateKeyContent = (val ? strndup(val, len) : NULL); return (!val || settings->PrivateKeyContent != NULL); case FreeRDP_PrivateKeyFile: if (cleanup) free(settings->PrivateKeyFile); - settings->PrivateKeyFile = (val ? _strdup(val) : NULL); + settings->PrivateKeyFile = (val ? strndup(val, len) : NULL); return (!val || settings->PrivateKeyFile != NULL); case FreeRDP_ProxyHostname: if (cleanup) free(settings->ProxyHostname); - settings->ProxyHostname = (val ? _strdup(val) : NULL); + settings->ProxyHostname = (val ? strndup(val, len) : NULL); return (!val || settings->ProxyHostname != NULL); case FreeRDP_ProxyPassword: if (cleanup) free(settings->ProxyPassword); - settings->ProxyPassword = (val ? _strdup(val) : NULL); + settings->ProxyPassword = (val ? strndup(val, len) : NULL); return (!val || settings->ProxyPassword != NULL); case FreeRDP_ProxyUsername: if (cleanup) free(settings->ProxyUsername); - settings->ProxyUsername = (val ? _strdup(val) : NULL); + settings->ProxyUsername = (val ? strndup(val, len) : NULL); return (!val || settings->ProxyUsername != NULL); case FreeRDP_RDP2TCPArgs: if (cleanup) free(settings->RDP2TCPArgs); - settings->RDP2TCPArgs = (val ? _strdup(val) : NULL); + settings->RDP2TCPArgs = (val ? strndup(val, len) : NULL); return (!val || settings->RDP2TCPArgs != NULL); case FreeRDP_RdpKeyContent: if (cleanup) free(settings->RdpKeyContent); - settings->RdpKeyContent = (val ? _strdup(val) : NULL); + settings->RdpKeyContent = (val ? strndup(val, len) : NULL); return (!val || settings->RdpKeyContent != NULL); case FreeRDP_RdpKeyFile: if (cleanup) free(settings->RdpKeyFile); - settings->RdpKeyFile = (val ? _strdup(val) : NULL); + settings->RdpKeyFile = (val ? strndup(val, len) : NULL); return (!val || settings->RdpKeyFile != NULL); case FreeRDP_RedirectionAcceptedCert: if (cleanup) free(settings->RedirectionAcceptedCert); - settings->RedirectionAcceptedCert = (val ? _strdup(val) : NULL); + settings->RedirectionAcceptedCert = (val ? strndup(val, len) : NULL); return (!val || settings->RedirectionAcceptedCert != NULL); case FreeRDP_RedirectionDomain: if (cleanup) free(settings->RedirectionDomain); - settings->RedirectionDomain = (val ? _strdup(val) : NULL); + settings->RedirectionDomain = (val ? strndup(val, len) : NULL); return (!val || settings->RedirectionDomain != NULL); case FreeRDP_RedirectionTargetFQDN: if (cleanup) free(settings->RedirectionTargetFQDN); - settings->RedirectionTargetFQDN = (val ? _strdup(val) : NULL); + settings->RedirectionTargetFQDN = (val ? strndup(val, len) : NULL); return (!val || settings->RedirectionTargetFQDN != NULL); case FreeRDP_RedirectionTargetNetBiosName: if (cleanup) free(settings->RedirectionTargetNetBiosName); - settings->RedirectionTargetNetBiosName = (val ? _strdup(val) : NULL); + settings->RedirectionTargetNetBiosName = (val ? strndup(val, len) : NULL); return (!val || settings->RedirectionTargetNetBiosName != NULL); case FreeRDP_RedirectionUsername: if (cleanup) free(settings->RedirectionUsername); - settings->RedirectionUsername = (val ? _strdup(val) : NULL); + settings->RedirectionUsername = (val ? strndup(val, len) : NULL); return (!val || settings->RedirectionUsername != NULL); case FreeRDP_RemoteApplicationCmdLine: if (cleanup) free(settings->RemoteApplicationCmdLine); - settings->RemoteApplicationCmdLine = (val ? _strdup(val) : NULL); + settings->RemoteApplicationCmdLine = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationCmdLine != NULL); case FreeRDP_RemoteApplicationFile: if (cleanup) free(settings->RemoteApplicationFile); - settings->RemoteApplicationFile = (val ? _strdup(val) : NULL); + settings->RemoteApplicationFile = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationFile != NULL); case FreeRDP_RemoteApplicationGuid: if (cleanup) free(settings->RemoteApplicationGuid); - settings->RemoteApplicationGuid = (val ? _strdup(val) : NULL); + settings->RemoteApplicationGuid = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationGuid != NULL); case FreeRDP_RemoteApplicationIcon: if (cleanup) free(settings->RemoteApplicationIcon); - settings->RemoteApplicationIcon = (val ? _strdup(val) : NULL); + settings->RemoteApplicationIcon = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationIcon != NULL); case FreeRDP_RemoteApplicationName: if (cleanup) free(settings->RemoteApplicationName); - settings->RemoteApplicationName = (val ? _strdup(val) : NULL); + settings->RemoteApplicationName = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationName != NULL); case FreeRDP_RemoteApplicationProgram: if (cleanup) free(settings->RemoteApplicationProgram); - settings->RemoteApplicationProgram = (val ? _strdup(val) : NULL); + settings->RemoteApplicationProgram = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationProgram != NULL); case FreeRDP_RemoteApplicationWorkingDir: if (cleanup) free(settings->RemoteApplicationWorkingDir); - settings->RemoteApplicationWorkingDir = (val ? _strdup(val) : NULL); + settings->RemoteApplicationWorkingDir = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteApplicationWorkingDir != NULL); case FreeRDP_RemoteAssistancePassStub: if (cleanup) free(settings->RemoteAssistancePassStub); - settings->RemoteAssistancePassStub = (val ? _strdup(val) : NULL); + settings->RemoteAssistancePassStub = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteAssistancePassStub != NULL); case FreeRDP_RemoteAssistancePassword: if (cleanup) free(settings->RemoteAssistancePassword); - settings->RemoteAssistancePassword = (val ? _strdup(val) : NULL); + settings->RemoteAssistancePassword = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteAssistancePassword != NULL); case FreeRDP_RemoteAssistanceRCTicket: if (cleanup) free(settings->RemoteAssistanceRCTicket); - settings->RemoteAssistanceRCTicket = (val ? _strdup(val) : NULL); + settings->RemoteAssistanceRCTicket = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteAssistanceRCTicket != NULL); case FreeRDP_RemoteAssistanceSessionId: if (cleanup) free(settings->RemoteAssistanceSessionId); - settings->RemoteAssistanceSessionId = (val ? _strdup(val) : NULL); + settings->RemoteAssistanceSessionId = (val ? strndup(val, len) : NULL); return (!val || settings->RemoteAssistanceSessionId != NULL); case FreeRDP_ServerHostname: if (cleanup) free(settings->ServerHostname); - settings->ServerHostname = (val ? _strdup(val) : NULL); + settings->ServerHostname = (val ? strndup(val, len) : NULL); return (!val || settings->ServerHostname != NULL); case FreeRDP_ShellWorkingDirectory: if (cleanup) free(settings->ShellWorkingDirectory); - settings->ShellWorkingDirectory = (val ? _strdup(val) : NULL); + settings->ShellWorkingDirectory = (val ? strndup(val, len) : NULL); return (!val || settings->ShellWorkingDirectory != NULL); case FreeRDP_TargetNetAddress: if (cleanup) free(settings->TargetNetAddress); - settings->TargetNetAddress = (val ? _strdup(val) : NULL); + settings->TargetNetAddress = (val ? strndup(val, len) : NULL); return (!val || settings->TargetNetAddress != NULL); case FreeRDP_Username: if (cleanup) free(settings->Username); - settings->Username = (val ? _strdup(val) : NULL); + settings->Username = (val ? strndup(val, len) : NULL); return (!val || settings->Username != NULL); case FreeRDP_WindowTitle: if (cleanup) free(settings->WindowTitle); - settings->WindowTitle = (val ? _strdup(val) : NULL); + settings->WindowTitle = (val ? strndup(val, len) : NULL); return (!val || settings->WindowTitle != NULL); case FreeRDP_WmClass: if (cleanup) free(settings->WmClass); - settings->WmClass = (val ? _strdup(val) : NULL); + settings->WmClass = (val ? strndup(val, len) : NULL); return (!val || settings->WmClass != NULL); default: @@ -2784,12 +2810,20 @@ BOOL freerdp_settings_set_string_(rdpSettings* settings, size_t id, const char* return TRUE; } -BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* val) +BOOL freerdp_settings_set_string_len(rdpSettings* settings, size_t id, const char* val, size_t len) { - return freerdp_settings_set_string_(settings, id, val, TRUE); + return freerdp_settings_set_string_(settings, id, val, len, TRUE); } -const void* freerdp_settings_get_pointer(const rdpSettings* settings, size_t id) +BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* val) +{ + size_t len = 0; + if (val) + len = strlen(val); + return freerdp_settings_set_string_(settings, id, val, len, TRUE); +} + +void* freerdp_settings_get_pointer_writable(const rdpSettings* settings, size_t id) { if (!settings) return FALSE; diff --git a/libfreerdp/common/settings_str.c b/libfreerdp/common/settings_str.c index 158277a16..9fa594d1e 100644 --- a/libfreerdp/common/settings_str.c +++ b/libfreerdp/common/settings_str.c @@ -215,6 +215,7 @@ static const struct settings_str_entry settings_map[] = { { FreeRDP_EncryptionLevel, 3, "FreeRDP_EncryptionLevel" }, { FreeRDP_EncryptionMethods, 3, "FreeRDP_EncryptionMethods" }, { FreeRDP_ExtEncryptionMethods, 3, "FreeRDP_ExtEncryptionMethods" }, + { FreeRDP_Floatbar, 3, "FreeRDP_Floatbar" }, { FreeRDP_FrameAcknowledge, 3, "FreeRDP_FrameAcknowledge" }, { FreeRDP_GatewayAcceptedCertLength, 3, "FreeRDP_GatewayAcceptedCertLength" }, { FreeRDP_GatewayCredentialsSource, 3, "FreeRDP_GatewayCredentialsSource" }, @@ -288,6 +289,7 @@ static const struct settings_str_entry settings_map[] = { { FreeRDP_TcpKeepAliveDelay, 3, "FreeRDP_TcpKeepAliveDelay" }, { FreeRDP_TcpKeepAliveInterval, 3, "FreeRDP_TcpKeepAliveInterval" }, { FreeRDP_TcpKeepAliveRetries, 3, "FreeRDP_TcpKeepAliveRetries" }, + { FreeRDP_ThreadingFlags, 3, "FreeRDP_ThreadingFlags" }, { FreeRDP_TlsSecLevel, 3, "FreeRDP_TlsSecLevel" }, { FreeRDP_VirtualChannelChunkSize, 3, "FreeRDP_VirtualChannelChunkSize" }, { FreeRDP_VirtualChannelCompressionFlags, 3, "FreeRDP_VirtualChannelCompressionFlags" }, @@ -295,6 +297,7 @@ static const struct settings_str_entry settings_map[] = { { FreeRDP_YPan, 4, "FreeRDP_YPan" }, { FreeRDP_ParentWindowId, 5, "FreeRDP_ParentWindowId" }, { FreeRDP_AcceptedCert, 7, "FreeRDP_AcceptedCert" }, + { FreeRDP_ActionScript, 7, "FreeRDP_ActionScript" }, { FreeRDP_AllowedTlsCiphers, 7, "FreeRDP_AllowedTlsCiphers" }, { FreeRDP_AlternateShell, 7, "FreeRDP_AlternateShell" }, { FreeRDP_AssistanceFile, 7, "FreeRDP_AssistanceFile" }, @@ -449,7 +452,10 @@ BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src) case 7: /* strings */ { const char* sval = freerdp_settings_get_string(src, cur->id); - if (!freerdp_settings_set_string_(dst, cur->id, sval, FALSE)) + size_t len = 0; + if (sval) + len = strlen(sval); + if (!freerdp_settings_set_string_(dst, cur->id, sval, len, FALSE)) return FALSE; } break; @@ -540,10 +546,10 @@ void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup) switch (cur->type) { case 7: /* strings */ - freerdp_settings_set_string_(dst, cur->id, NULL, cleanup); + freerdp_settings_set_string_(dst, cur->id, NULL, 0, cleanup); break; case 8: /* pointer */ - freerdp_settings_set_pointer(dst, cur->id, NULL); + freerdp_settings_set_pointer_len(dst, cur->id, NULL, 0); break; } } diff --git a/libfreerdp/core/settings.c b/libfreerdp/core/settings.c index a888a7f15..5753c5625 100644 --- a/libfreerdp/core/settings.c +++ b/libfreerdp/core/settings.c @@ -42,6 +42,8 @@ #include "settings.h" +#define TAG FREERDP_TAG("settings") + #ifdef _WIN32 #pragma warning(push) #pragma warning(disable : 4244) @@ -76,42 +78,61 @@ static void settings_client_load_hkey_local_machine(rdpSettings* settings) if (status == ERROR_SUCCESS) { - REG_QUERY_DWORD_VALUE(hKey, _T("DesktopWidth"), dwType, dwValue, dwSize, - settings->DesktopWidth); - REG_QUERY_DWORD_VALUE(hKey, _T("DesktopHeight"), dwType, dwValue, dwSize, - settings->DesktopHeight); + UINT32 DesktopWidth = 0, DesktopHeight = 0, ColorDepth = 0; + UINT32 KeyboardType = 0, KeyboardSubType = 0, KeyboardLayout = 0, KeyboardFunctionKey = 0; + UINT32 CookieMaxLength = 0, BitmapCacheEnabled = 0, OffscreenSupportLevel = 0, + OffscreenCacheSize = 0, OffscreenCacheEntries = 0; + BOOL ExtSecurity = FALSE, NlaSecurity = FALSE, TlsSecurity = FALSE, RdpSecurity = FALSE, + MstscCookieMode = FALSE; + + REG_QUERY_DWORD_VALUE(hKey, _T("DesktopWidth"), dwType, dwValue, dwSize, DesktopWidth); + REG_QUERY_DWORD_VALUE(hKey, _T("DesktopHeight"), dwType, dwValue, dwSize, DesktopHeight); REG_QUERY_BOOL_VALUE(hKey, _T("Fullscreen"), dwType, dwValue, dwSize, settings->Fullscreen); - REG_QUERY_DWORD_VALUE(hKey, _T("ColorDepth"), dwType, dwValue, dwSize, - settings->ColorDepth); - REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardType"), dwType, dwValue, dwSize, - settings->KeyboardType); + REG_QUERY_DWORD_VALUE(hKey, _T("ColorDepth"), dwType, dwValue, dwSize, ColorDepth); + REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardType"), dwType, dwValue, dwSize, KeyboardType); REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardSubType"), dwType, dwValue, dwSize, - settings->KeyboardSubType); + KeyboardSubType); REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardFunctionKeys"), dwType, dwValue, dwSize, - settings->KeyboardFunctionKey); - REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardLayout"), dwType, dwValue, dwSize, - settings->KeyboardLayout); - REG_QUERY_BOOL_VALUE(hKey, _T("ExtSecurity"), dwType, dwValue, dwSize, - settings->ExtSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("NlaSecurity"), dwType, dwValue, dwSize, - settings->NlaSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("TlsSecurity"), dwType, dwValue, dwSize, - settings->TlsSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("RdpSecurity"), dwType, dwValue, dwSize, - settings->RdpSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("MstscCookieMode"), dwType, dwValue, dwSize, - settings->MstscCookieMode); + KeyboardFunctionKey); + REG_QUERY_DWORD_VALUE(hKey, _T("KeyboardLayout"), dwType, dwValue, dwSize, KeyboardLayout); + REG_QUERY_BOOL_VALUE(hKey, _T("ExtSecurity"), dwType, dwValue, dwSize, ExtSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("NlaSecurity"), dwType, dwValue, dwSize, NlaSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("TlsSecurity"), dwType, dwValue, dwSize, TlsSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("RdpSecurity"), dwType, dwValue, dwSize, RdpSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("MstscCookieMode"), dwType, dwValue, dwSize, MstscCookieMode); REG_QUERY_DWORD_VALUE(hKey, _T("CookieMaxLength"), dwType, dwValue, dwSize, - settings->CookieMaxLength); - REG_QUERY_BOOL_VALUE(hKey, _T("BitmapCache"), dwType, dwValue, dwSize, - settings->BitmapCacheEnabled); + CookieMaxLength); + REG_QUERY_BOOL_VALUE(hKey, _T("BitmapCache"), dwType, dwValue, dwSize, BitmapCacheEnabled); REG_QUERY_BOOL_VALUE(hKey, _T("OffscreenBitmapCache"), dwType, dwValue, dwSize, - settings->OffscreenSupportLevel); + OffscreenSupportLevel); REG_QUERY_DWORD_VALUE(hKey, _T("OffscreenBitmapCacheSize"), dwType, dwValue, dwSize, - settings->OffscreenCacheSize); + OffscreenCacheSize); REG_QUERY_DWORD_VALUE(hKey, _T("OffscreenBitmapCacheEntries"), dwType, dwValue, dwSize, - settings->OffscreenCacheEntries); + OffscreenCacheEntries); RegCloseKey(hKey); + + if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, DesktopWidth) || + !freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, DesktopHeight) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardType, KeyboardType) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardSubType, KeyboardSubType) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardFunctionKey, + KeyboardFunctionKey) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, KeyboardLayout) || + !freerdp_settings_set_bool(settings, FreeRDP_BitmapCacheEnabled, BitmapCacheEnabled) || + !freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, ExtSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, NlaSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TlsSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, RdpSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_MstscCookieMode, MstscCookieMode) || + !freerdp_settings_set_uint32(settings, FreeRDP_CookieMaxLength, CookieMaxLength) || + !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenSupportLevel, + OffscreenSupportLevel) || + !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheSize, + OffscreenCacheSize) || + !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheEntries, + OffscreenCacheEntries) || + !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, ColorDepth)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); } status = @@ -119,31 +140,34 @@ static void settings_client_load_hkey_local_machine(rdpSettings* settings) if (status == ERROR_SUCCESS) { - REG_QUERY_DWORD_VALUE(hKey, _T("NumCells"), dwType, dwValue, dwSize, - settings->BitmapCacheV2NumCells); - REG_QUERY_DWORD_VALUE(hKey, _T("Cell0NumEntries"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[0].numEntries); - REG_QUERY_BOOL_VALUE(hKey, _T("Cell0Persistent"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[0].persistent); - REG_QUERY_DWORD_VALUE(hKey, _T("Cell1NumEntries"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[1].numEntries); - REG_QUERY_BOOL_VALUE(hKey, _T("Cell1Persistent"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[1].persistent); - REG_QUERY_DWORD_VALUE(hKey, _T("Cell2NumEntries"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[2].numEntries); - REG_QUERY_BOOL_VALUE(hKey, _T("Cell2Persistent"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[2].persistent); - REG_QUERY_DWORD_VALUE(hKey, _T("Cell3NumEntries"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[3].numEntries); - REG_QUERY_BOOL_VALUE(hKey, _T("Cell3Persistent"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[3].persistent); - REG_QUERY_DWORD_VALUE(hKey, _T("Cell4NumEntries"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[4].numEntries); - REG_QUERY_BOOL_VALUE(hKey, _T("Cell4Persistent"), dwType, dwValue, dwSize, - settings->BitmapCacheV2CellInfo[4].persistent); + unsigned x; + UINT32 BitmapCacheV2NumCells = 0; + BOOL AllowCacheWaitingList = FALSE; + + REG_QUERY_DWORD_VALUE(hKey, _T("NumCells"), dwType, dwValue, dwSize, BitmapCacheV2NumCells); + for (x = 0; x < 5; x++) + { + TCHAR numentries[64] = { 0 }; + TCHAR persist[64] = { 0 }; + BITMAP_CACHE_V2_CELL_INFO cache = { 0 }; + _sntprintf(numentries, ARRAYSIZE(numentries), _T("Cell%uNumEntries"), x); + _sntprintf(persist, ARRAYSIZE(persist), _T("Cell%uPersistent"), x); + REG_QUERY_DWORD_VALUE(hKey, numentries, dwType, dwValue, dwSize, cache.numEntries); + REG_QUERY_BOOL_VALUE(hKey, persist, dwType, dwValue, dwSize, cache.persistent); + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, x, + &cache)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); + } + REG_QUERY_BOOL_VALUE(hKey, _T("AllowCacheWaitingList"), dwType, dwValue, dwSize, - settings->AllowCacheWaitingList); + AllowCacheWaitingList); RegCloseKey(hKey); + + if (!freerdp_settings_set_bool(settings, FreeRDP_AllowCacheWaitingList, + AllowCacheWaitingList) || + !freerdp_settings_set_uint32(settings, FreeRDP_BitmapCacheV2NumCells, + BitmapCacheV2NumCells)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); } status = @@ -151,53 +175,37 @@ static void settings_client_load_hkey_local_machine(rdpSettings* settings) if (status == ERROR_SUCCESS) { - REG_QUERY_DWORD_VALUE(hKey, _T("SupportLevel"), dwType, dwValue, dwSize, - settings->GlyphSupportLevel); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache0NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[0].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache0MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[0].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache1NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[1].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache1MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[1].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache2NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[2].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache2MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[2].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache3NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[3].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache3MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[3].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache4NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[4].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache4MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[4].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache5NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[5].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache5MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[5].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache6NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[6].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache6MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[6].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache7NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[7].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache7MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[7].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache8NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[8].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache8MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[8].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache9NumEntries"), dwType, dwValue, dwSize, - settings->GlyphCache[9].cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("Cache9MaxCellSize"), dwType, dwValue, dwSize, - settings->GlyphCache[9].cacheMaximumCellSize); - REG_QUERY_DWORD_VALUE(hKey, _T("FragCacheNumEntries"), dwType, dwValue, dwSize, - settings->FragCache->cacheEntries); - REG_QUERY_DWORD_VALUE(hKey, _T("FragCacheMaxCellSize"), dwType, dwValue, dwSize, - settings->FragCache->cacheMaximumCellSize); + unsigned x; + UINT32 GlyphSupportLevel = 0; + REG_QUERY_DWORD_VALUE(hKey, _T("SupportLevel"), dwType, dwValue, dwSize, GlyphSupportLevel); + for (x = 0; x < 10; x++) + { + GLYPH_CACHE_DEFINITION cache = { 0 }; + TCHAR numentries[64] = { 0 }; + TCHAR maxsize[64] = { 0 }; + _sntprintf(numentries, ARRAYSIZE(numentries), "Cache%uNumEntries", x); + _sntprintf(maxsize, ARRAYSIZE(maxsize), "Cache%uMaxCellSize", x); + + REG_QUERY_DWORD_VALUE(hKey, numentries, dwType, dwValue, dwSize, cache.cacheEntries); + REG_QUERY_DWORD_VALUE(hKey, maxsize, dwType, dwValue, dwSize, + cache.cacheMaximumCellSize); + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_GlyphCache, x, &cache)) + WLog_WARN(TAG, "Failed to store GlyphCache %" PRIuz, x); + } + { + GLYPH_CACHE_DEFINITION cache = { 0 }; + REG_QUERY_DWORD_VALUE(hKey, _T("FragCacheNumEntries"), dwType, dwValue, dwSize, + cache.cacheEntries); + REG_QUERY_DWORD_VALUE(hKey, _T("FragCacheMaxCellSize"), dwType, dwValue, dwSize, + cache.cacheMaximumCellSize); + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_FragCache, x, &cache)) + WLog_WARN(TAG, "Failed to store FragCache"); + } + RegCloseKey(hKey); + + if (!freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GlyphSupportLevel)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); } status = @@ -205,13 +213,19 @@ static void settings_client_load_hkey_local_machine(rdpSettings* settings) if (status == ERROR_SUCCESS) { - REG_QUERY_BOOL_VALUE(hKey, _T("LargePointer"), dwType, dwValue, dwSize, - settings->LargePointerFlag); - REG_QUERY_BOOL_VALUE(hKey, _T("ColorPointer"), dwType, dwValue, dwSize, - settings->ColorPointerFlag); + BOOL ColorPointerFlag = FALSE; + UINT32 LargePointerFlag = 0; + UINT32 PointerCacheSize = 0; + REG_QUERY_BOOL_VALUE(hKey, _T("LargePointer"), dwType, dwValue, dwSize, LargePointerFlag); + REG_QUERY_BOOL_VALUE(hKey, _T("ColorPointer"), dwType, dwValue, dwSize, ColorPointerFlag); REG_QUERY_DWORD_VALUE(hKey, _T("PointerCacheSize"), dwType, dwValue, dwSize, - settings->PointerCacheSize); + PointerCacheSize); RegCloseKey(hKey); + + if (!freerdp_settings_set_bool(settings, FreeRDP_ColorPointerFlag, ColorPointerFlag) || + !freerdp_settings_set_uint32(settings, FreeRDP_LargePointerFlag, LargePointerFlag) || + !freerdp_settings_set_uint32(settings, FreeRDP_PointerCacheSize, PointerCacheSize)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); } } @@ -219,24 +233,33 @@ static void settings_server_load_hkey_local_machine(rdpSettings* settings) { HKEY hKey; LONG status; - DWORD dwType; - DWORD dwSize; - DWORD dwValue; + DWORD dwType = 0; + DWORD dwSize = 0; + DWORD dwValue = 0; + + BOOL ExtSecurity = FALSE, NlaSecurity = FALSE, TlsSecurity = FALSE, RdpSecurity = FALSE; + status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, SERVER_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey); if (status != ERROR_SUCCESS) return; - REG_QUERY_BOOL_VALUE(hKey, _T("ExtSecurity"), dwType, dwValue, dwSize, settings->ExtSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("NlaSecurity"), dwType, dwValue, dwSize, settings->NlaSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("TlsSecurity"), dwType, dwValue, dwSize, settings->TlsSecurity); - REG_QUERY_BOOL_VALUE(hKey, _T("RdpSecurity"), dwType, dwValue, dwSize, settings->RdpSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("ExtSecurity"), dwType, dwValue, dwSize, ExtSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("NlaSecurity"), dwType, dwValue, dwSize, NlaSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("TlsSecurity"), dwType, dwValue, dwSize, TlsSecurity); + REG_QUERY_BOOL_VALUE(hKey, _T("RdpSecurity"), dwType, dwValue, dwSize, RdpSecurity); RegCloseKey(hKey); + + if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, ExtSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, NlaSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TlsSecurity) || + !freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, RdpSecurity)) + WLog_WARN(TAG, "Failed to load registry keys to settings!"); } static void settings_load_hkey_local_machine(rdpSettings* settings) { - if (settings->ServerMode) + if (freerdp_settings_get_bool(settings, FreeRDP_ServerMode)) settings_server_load_hkey_local_machine(settings); else settings_client_load_hkey_local_machine(settings); @@ -258,42 +281,48 @@ static BOOL settings_get_computer_name(rdpSettings* settings) BOOL freerdp_settings_set_default_order_support(rdpSettings* settings) { - if (!settings) + BYTE* OrderSupport = freerdp_settings_get_pointer_writable(settings, FreeRDP_OrderSupport); + if (!OrderSupport) return FALSE; - ZeroMemory(settings->OrderSupport, 32); - settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE; - settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE; - settings->OrderSupport[NEG_SCRBLT_INDEX] = TRUE; - settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE; - settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE; - settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE; - settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE; - settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE; - settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE; - settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE; - settings->OrderSupport[NEG_LINETO_INDEX] = TRUE; - settings->OrderSupport[NEG_POLYLINE_INDEX] = TRUE; - settings->OrderSupport[NEG_MEMBLT_INDEX] = settings->BitmapCacheEnabled; - settings->OrderSupport[NEG_MEM3BLT_INDEX] = settings->BitmapCacheEnabled; - settings->OrderSupport[NEG_MEMBLT_V2_INDEX] = settings->BitmapCacheEnabled; - settings->OrderSupport[NEG_MEM3BLT_V2_INDEX] = settings->BitmapCacheEnabled; - settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE; - settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = - settings->GlyphSupportLevel != GLYPH_SUPPORT_NONE; - settings->OrderSupport[NEG_FAST_INDEX_INDEX] = - settings->GlyphSupportLevel != GLYPH_SUPPORT_NONE; - settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = - settings->GlyphSupportLevel != GLYPH_SUPPORT_NONE; - settings->OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE; - settings->OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE; - settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE; - settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE; + ZeroMemory(OrderSupport, 32); + OrderSupport[NEG_DSTBLT_INDEX] = TRUE; + OrderSupport[NEG_PATBLT_INDEX] = TRUE; + OrderSupport[NEG_SCRBLT_INDEX] = TRUE; + OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE; + OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE; + OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE; + OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE; + OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE; + OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE; + OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE; + OrderSupport[NEG_LINETO_INDEX] = TRUE; + OrderSupport[NEG_POLYLINE_INDEX] = TRUE; + OrderSupport[NEG_MEMBLT_INDEX] = + freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled); + OrderSupport[NEG_MEM3BLT_INDEX] = + freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled); + OrderSupport[NEG_MEMBLT_V2_INDEX] = + freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled); + OrderSupport[NEG_MEM3BLT_V2_INDEX] = + freerdp_settings_get_bool(settings, FreeRDP_BitmapCacheEnabled); + OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE; + OrderSupport[NEG_GLYPH_INDEX_INDEX] = + freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE; + OrderSupport[NEG_FAST_INDEX_INDEX] = + freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE; + OrderSupport[NEG_FAST_GLYPH_INDEX] = + freerdp_settings_get_uint32(settings, FreeRDP_GlyphSupportLevel) != GLYPH_SUPPORT_NONE; + OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE; + OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE; + OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE; + OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE; return TRUE; } rdpSettings* freerdp_settings_new(DWORD flags) { + size_t x; char* base; rdpSettings* settings; settings = (rdpSettings*)calloc(1, sizeof(rdpSettings)); @@ -301,89 +330,96 @@ rdpSettings* freerdp_settings_new(DWORD flags) if (!settings) return NULL; - settings->HiDefRemoteApp = FALSE; - settings->RemoteApplicationSupportMask = - RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED | - RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED | - RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED | - RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED; - settings->SupportHeartbeatPdu = TRUE; - settings->ServerMode = (flags & FREERDP_SETTINGS_SERVER_MODE) ? TRUE : FALSE; - settings->WaitForOutputBufferFlush = TRUE; - settings->MaxTimeInCheckLoop = 100; - settings->DesktopWidth = 1024; - settings->DesktopHeight = 768; - settings->Workarea = FALSE; - settings->Fullscreen = FALSE; - settings->GrabKeyboard = TRUE; - settings->GrabMouse = TRUE; - settings->Decorations = TRUE; - settings->RdpVersion = RDP_VERSION_10_7; - settings->ColorDepth = 16; - settings->ExtSecurity = FALSE; - settings->NlaSecurity = TRUE; - settings->TlsSecurity = TRUE; - settings->RdpSecurity = TRUE; - settings->NegotiateSecurityLayer = TRUE; - settings->RestrictedAdminModeRequired = FALSE; - settings->MstscCookieMode = FALSE; - settings->CookieMaxLength = DEFAULT_COOKIE_MAX_LENGTH; - settings->ClientBuild = 18363; /* Windows 10, Version 1909 */ - settings->KeyboardType = 4; - settings->KeyboardSubType = 0; - settings->KeyboardFunctionKey = 12; - settings->KeyboardLayout = 0; - settings->KeyboardHook = KEYBOARD_HOOK_FULLSCREEN_ONLY; - settings->UseRdpSecurityLayer = FALSE; - settings->SaltedChecksum = TRUE; - settings->ServerPort = 3389; - settings->GatewayPort = 443; - settings->DesktopResize = TRUE; - settings->ToggleFullscreen = TRUE; - settings->DesktopPosX = UINT32_MAX; - settings->DesktopPosY = UINT32_MAX; - settings->SoftwareGdi = TRUE; - settings->UnmapButtons = FALSE; - settings->PerformanceFlags = PERF_FLAG_NONE; - settings->AllowFontSmoothing = TRUE; - settings->AllowDesktopComposition = FALSE; - settings->DisableWallpaper = FALSE; - settings->DisableFullWindowDrag = TRUE; - settings->DisableMenuAnims = TRUE; - settings->DisableThemes = FALSE; - settings->ConnectionType = CONNECTION_TYPE_LAN; - settings->NetworkAutoDetect = TRUE; - settings->EncryptionMethods = ENCRYPTION_METHOD_NONE; - settings->EncryptionLevel = ENCRYPTION_LEVEL_NONE; - settings->FIPSMode = FALSE; - settings->CompressionEnabled = TRUE; - settings->LogonNotify = TRUE; - settings->BrushSupportLevel = BRUSH_COLOR_FULL; - settings->CompressionLevel = PACKET_COMPR_TYPE_RDP61; - settings->Authentication = TRUE; - settings->AuthenticationOnly = FALSE; - settings->CredentialsFromStdin = FALSE; - settings->DisableCredentialsDelegation = FALSE; - settings->AuthenticationLevel = 2; - settings->ChannelCount = 0; - settings->ChannelDefArraySize = 32; - settings->ChannelDefArray = - (CHANNEL_DEF*)calloc(settings->ChannelDefArraySize, sizeof(CHANNEL_DEF)); + if (!freerdp_settings_set_bool(settings, FreeRDP_HiDefRemoteApp, FALSE) || + !freerdp_settings_set_uint32( + settings, FreeRDP_RemoteApplicationSupportMask, + RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED | + RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED | + RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | + RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED | RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | + RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED) || + !freerdp_settings_set_bool(settings, FreeRDP_SupportHeartbeatPdu, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_ServerMode, + (flags & FREERDP_SETTINGS_SERVER_MODE) ? TRUE : FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_WaitForOutputBufferFlush, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_MaxTimeInCheckLoop, 100) || + !freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 1024) || + !freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 768) || + !freerdp_settings_set_bool(settings, FreeRDP_Workarea, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_Fullscreen, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GrabKeyboard, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_Decorations, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_RdpVersion, RDP_VERSION_10_7) || + !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 16) || + !freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_NegotiateSecurityLayer, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_RestrictedAdminModeRequired, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_MstscCookieMode, FALSE) || + !freerdp_settings_set_uint32(settings, FreeRDP_CookieMaxLength, + DEFAULT_COOKIE_MAX_LENGTH) || + !freerdp_settings_set_uint32(settings, FreeRDP_ClientBuild, + 18363) || /* Windows 10, Version 1909 */ + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardType, 4) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardSubType, 0) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardFunctionKey, 12) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, 0) || + !freerdp_settings_set_uint32(settings, FreeRDP_KeyboardHook, + KEYBOARD_HOOK_FULLSCREEN_ONLY) || + !freerdp_settings_set_bool(settings, FreeRDP_UseRdpSecurityLayer, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_SaltedChecksum, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, 3389) || + !freerdp_settings_set_uint32(settings, FreeRDP_GatewayPort, 443) || + !freerdp_settings_set_bool(settings, FreeRDP_DesktopResize, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_ToggleFullscreen, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_DesktopPosX, UINT32_MAX) || + !freerdp_settings_set_uint32(settings, FreeRDP_DesktopPosY, UINT32_MAX) || + !freerdp_settings_set_bool(settings, FreeRDP_SoftwareGdi, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_UnmapButtons, FALSE) || + !freerdp_settings_set_uint32(settings, FreeRDP_PerformanceFlags, PERF_FLAG_NONE) || + !freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_DisableWallpaper, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_DisableThemes, FALSE) || + !freerdp_settings_set_uint32(settings, FreeRDP_ConnectionType, CONNECTION_TYPE_LAN) || + !freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_EncryptionMethods, ENCRYPTION_METHOD_NONE) || + !freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel, ENCRYPTION_LEVEL_NONE) || + !freerdp_settings_set_bool(settings, FreeRDP_FIPSMode, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_CompressionEnabled, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_LogonNotify, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_BrushSupportLevel, BRUSH_COLOR_FULL) || + !freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP61) || + !freerdp_settings_set_bool(settings, FreeRDP_Authentication, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_AuthenticationOnly, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_CredentialsFromStdin, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_DisableCredentialsDelegation, FALSE) || + !freerdp_settings_set_uint32(settings, FreeRDP_AuthenticationLevel, 2) || + !freerdp_settings_set_uint32(settings, FreeRDP_ChannelCount, 0) || + !freerdp_settings_set_uint32(settings, FreeRDP_ChannelDefArraySize, 32)) + goto out_fail; + + settings->ChannelDefArray = (CHANNEL_DEF*)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize), sizeof(CHANNEL_DEF)); if (!settings->ChannelDefArray) goto out_fail; - settings->SupportMonitorLayoutPdu = FALSE; - settings->MonitorCount = 0; - settings->MonitorDefArraySize = 32; - settings->MonitorDefArray = - (rdpMonitor*)calloc(settings->MonitorDefArraySize, sizeof(rdpMonitor)); + freerdp_settings_set_bool(settings, FreeRDP_SupportMonitorLayoutPdu, FALSE); + freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount, 0); + freerdp_settings_set_uint32(settings, FreeRDP_MonitorDefArraySize, 32); + settings->MonitorDefArray = (rdpMonitor*)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize), sizeof(rdpMonitor)); if (!settings->MonitorDefArray) goto out_fail; - settings->MonitorLocalShiftX = 0; - settings->MonitorLocalShiftY = 0; + freerdp_settings_set_uint32(settings, FreeRDP_MonitorLocalShiftX, 0); + freerdp_settings_set_uint32(settings, FreeRDP_MonitorLocalShiftY, 0); settings->MonitorIds = (UINT32*)calloc(16, sizeof(UINT32)); if (!settings->MonitorIds) @@ -397,50 +433,59 @@ rdpSettings* freerdp_settings_new(DWORD flags) if (!settings->ReceivedCapabilities) goto out_fail; - settings->ClientProductId = calloc(1, 32); + { + char tmp[32] = { 0 }; + if (!freerdp_settings_set_string_len(settings, FreeRDP_ClientProductId, tmp, sizeof(tmp))) + goto out_fail; + } - if (!settings->ClientProductId) + { + char ClientHostname[33] = { 0 }; + gethostname(ClientHostname, 31); + if (!freerdp_settings_set_string(settings, FreeRDP_ClientHostname, ClientHostname)) + goto out_fail; + } + if (!freerdp_settings_set_bool(settings, FreeRDP_ColorPointerFlag, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_LargePointerFlag, + (LARGE_POINTER_FLAG_96x96 | LARGE_POINTER_FLAG_384x384)) || + !freerdp_settings_set_uint32(settings, FreeRDP_PointerCacheSize, 20) || + !freerdp_settings_set_bool(settings, FreeRDP_SoundBeepsEnabled, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_DrawGdiPlusEnabled, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowSkipAlpha, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowColorSubsampling, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_DrawAllowDynamicColorFidelity, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_FrameMarkerCommandEnabled, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_AllowCacheWaitingList, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_BitmapCacheV2NumCells, 5)) goto out_fail; - - settings->ClientHostname = calloc(1, 32); - - if (!settings->ClientHostname) - goto out_fail; - - gethostname(settings->ClientHostname, 31); - settings->ClientHostname[31] = 0; - settings->ColorPointerFlag = TRUE; - settings->LargePointerFlag = (LARGE_POINTER_FLAG_96x96 | LARGE_POINTER_FLAG_384x384); - settings->PointerCacheSize = 20; - settings->SoundBeepsEnabled = TRUE; - settings->DrawGdiPlusEnabled = FALSE; - settings->DrawAllowSkipAlpha = TRUE; - settings->DrawAllowColorSubsampling = TRUE; - settings->DrawAllowDynamicColorFidelity = TRUE; - settings->FrameMarkerCommandEnabled = TRUE; - settings->SurfaceFrameMarkerEnabled = TRUE; - settings->AllowCacheWaitingList = TRUE; - settings->BitmapCacheV2NumCells = 5; settings->BitmapCacheV2CellInfo = (BITMAP_CACHE_V2_CELL_INFO*)calloc(6, sizeof(BITMAP_CACHE_V2_CELL_INFO)); if (!settings->BitmapCacheV2CellInfo) goto out_fail; - settings->BitmapCacheV2CellInfo[0].numEntries = 600; - settings->BitmapCacheV2CellInfo[0].persistent = FALSE; - settings->BitmapCacheV2CellInfo[1].numEntries = 600; - settings->BitmapCacheV2CellInfo[1].persistent = FALSE; - settings->BitmapCacheV2CellInfo[2].numEntries = 2048; - settings->BitmapCacheV2CellInfo[2].persistent = FALSE; - settings->BitmapCacheV2CellInfo[3].numEntries = 4096; - settings->BitmapCacheV2CellInfo[3].persistent = FALSE; - settings->BitmapCacheV2CellInfo[4].numEntries = 2048; - settings->BitmapCacheV2CellInfo[4].persistent = FALSE; - settings->NoBitmapCompressionHeader = TRUE; - settings->RefreshRect = TRUE; - settings->SuppressOutput = TRUE; - settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE; + { + BITMAP_CACHE_V2_CELL_INFO cache = { 0 }; + cache.numEntries = 600; + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 0, + &cache) || + !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 1, &cache)) + goto out_fail; + cache.numEntries = 2048; + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 2, + &cache) || + !freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 4, &cache)) + goto out_fail; + cache.numEntries = 4096; + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_BitmapCacheV2CellInfo, 3, &cache)) + goto out_fail; + } + if (!freerdp_settings_set_bool(settings, FreeRDP_NoBitmapCompressionHeader, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GLYPH_SUPPORT_NONE)) + goto out_fail; settings->GlyphCache = calloc(10, sizeof(GLYPH_CACHE_DEFINITION)); if (!settings->GlyphCache) @@ -451,116 +496,147 @@ rdpSettings* freerdp_settings_new(DWORD flags) if (!settings->FragCache) goto out_fail; - settings->GlyphCache[0].cacheEntries = 254; - settings->GlyphCache[0].cacheMaximumCellSize = 4; - settings->GlyphCache[1].cacheEntries = 254; - settings->GlyphCache[1].cacheMaximumCellSize = 4; - settings->GlyphCache[2].cacheEntries = 254; - settings->GlyphCache[2].cacheMaximumCellSize = 8; - settings->GlyphCache[3].cacheEntries = 254; - settings->GlyphCache[3].cacheMaximumCellSize = 8; - settings->GlyphCache[4].cacheEntries = 254; - settings->GlyphCache[4].cacheMaximumCellSize = 16; - settings->GlyphCache[5].cacheEntries = 254; - settings->GlyphCache[5].cacheMaximumCellSize = 32; - settings->GlyphCache[6].cacheEntries = 254; - settings->GlyphCache[6].cacheMaximumCellSize = 64; - settings->GlyphCache[7].cacheEntries = 254; - settings->GlyphCache[7].cacheMaximumCellSize = 128; - settings->GlyphCache[8].cacheEntries = 254; - settings->GlyphCache[8].cacheMaximumCellSize = 256; - settings->GlyphCache[9].cacheEntries = 64; - settings->GlyphCache[9].cacheMaximumCellSize = 256; - settings->FragCache->cacheEntries = 256; - settings->FragCache->cacheMaximumCellSize = 256; - settings->OffscreenSupportLevel = FALSE; - settings->OffscreenCacheSize = 7680; - settings->OffscreenCacheEntries = 2000; - settings->DrawNineGridCacheSize = 2560; - settings->DrawNineGridCacheEntries = 256; - settings->ClientDir = _strdup(client_dll); + for (x = 0; x < 10; x++) + { + GLYPH_CACHE_DEFINITION cache = { 0 }; + cache.cacheEntries = 254; + switch (x) + { + case 0: + case 1: + cache.cacheMaximumCellSize = 4; + break; + case 2: + case 3: + cache.cacheMaximumCellSize = 8; + break; + case 4: + cache.cacheMaximumCellSize = 16; + break; + case 5: + cache.cacheMaximumCellSize = 32; + break; + case 6: + cache.cacheMaximumCellSize = 64; + break; + case 7: + cache.cacheMaximumCellSize = 128; + break; + case 8: + cache.cacheMaximumCellSize = 256; + break; + case 9: + cache.cacheMaximumCellSize = 256; + break; + } - if (!settings->ClientDir) - goto out_fail; - - settings->RemoteWndSupportLevel = WINDOW_LEVEL_SUPPORTED | WINDOW_LEVEL_SUPPORTED_EX; - settings->RemoteAppNumIconCaches = 3; - settings->RemoteAppNumIconCacheEntries = 12; - settings->VirtualChannelChunkSize = CHANNEL_CHUNK_LENGTH; - settings->MultifragMaxRequestSize = (flags & FREERDP_SETTINGS_SERVER_MODE) ? 0 : 0xFFFF; - settings->GatewayUseSameCredentials = FALSE; - settings->GatewayBypassLocal = FALSE; - settings->GatewayRpcTransport = TRUE; - settings->GatewayHttpTransport = TRUE; - settings->GatewayUdpTransport = TRUE; - settings->FastPathInput = TRUE; - settings->FastPathOutput = TRUE; - settings->LongCredentialsSupported = TRUE; - settings->FrameAcknowledge = 2; - settings->MouseMotion = TRUE; - settings->NSCodecColorLossLevel = 3; - settings->NSCodecAllowSubsampling = TRUE; - settings->NSCodecAllowDynamicColorFidelity = TRUE; - settings->AutoReconnectionEnabled = FALSE; - settings->AutoReconnectMaxRetries = 20; - settings->GfxThinClient = TRUE; - settings->GfxSmallCache = FALSE; - settings->GfxProgressive = FALSE; - settings->GfxProgressiveV2 = FALSE; - settings->GfxH264 = FALSE; - settings->GfxAVC444 = FALSE; - settings->GfxSendQoeAck = FALSE; - settings->ClientAutoReconnectCookie = - (ARC_CS_PRIVATE_PACKET*)calloc(1, sizeof(ARC_CS_PRIVATE_PACKET)); - - if (!settings->ClientAutoReconnectCookie) - goto out_fail; - - settings->ServerAutoReconnectCookie = - (ARC_SC_PRIVATE_PACKET*)calloc(1, sizeof(ARC_SC_PRIVATE_PACKET)); - - if (!settings->ServerAutoReconnectCookie) + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_GlyphCache, x, &cache)) + goto out_fail; + } + { + GLYPH_CACHE_DEFINITION cache = { 0 }; + cache.cacheEntries = 256; + cache.cacheMaximumCellSize = 256; + if (!freerdp_settings_set_pointer_array(settings, FreeRDP_FragCache, 0, &cache)) + goto out_fail; + } + if (!freerdp_settings_set_uint32(settings, FreeRDP_OffscreenSupportLevel, 0) || + !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheSize, 7680) || + !freerdp_settings_set_uint32(settings, FreeRDP_OffscreenCacheEntries, 2000) || + !freerdp_settings_set_uint32(settings, FreeRDP_DrawNineGridCacheSize, 2560) || + !freerdp_settings_set_uint32(settings, FreeRDP_DrawNineGridCacheEntries, 256) || + !freerdp_settings_set_string(settings, FreeRDP_ClientDir, client_dll) || + !freerdp_settings_get_string(settings, FreeRDP_ClientDir) || + !freerdp_settings_set_uint32(settings, FreeRDP_RemoteWndSupportLevel, + WINDOW_LEVEL_SUPPORTED | WINDOW_LEVEL_SUPPORTED_EX) || + !freerdp_settings_set_uint32(settings, FreeRDP_RemoteAppNumIconCaches, 3) || + !freerdp_settings_set_uint32(settings, FreeRDP_RemoteAppNumIconCacheEntries, 12) || + !freerdp_settings_set_uint32(settings, FreeRDP_VirtualChannelChunkSize, + CHANNEL_CHUNK_LENGTH) || + !freerdp_settings_set_uint32(settings, FreeRDP_MultifragMaxRequestSize, + (flags & FREERDP_SETTINGS_SERVER_MODE) ? 0 : 0xFFFF) || + !freerdp_settings_set_bool(settings, FreeRDP_GatewayUseSameCredentials, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GatewayRpcTransport, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_GatewayHttpTransport, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_GatewayUdpTransport, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_FastPathInput, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_FastPathOutput, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_LongCredentialsSupported, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_FrameAcknowledge, 2) || + !freerdp_settings_set_bool(settings, FreeRDP_MouseMotion, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_NSCodecColorLossLevel, 3) || + !freerdp_settings_set_bool(settings, FreeRDP_NSCodecAllowSubsampling, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_NSCodecAllowDynamicColorFidelity, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_AutoReconnectionEnabled, FALSE) || + !freerdp_settings_set_uint32(settings, FreeRDP_AutoReconnectMaxRetries, 20) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxThinClient, TRUE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxSmallCache, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxProgressive, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxProgressiveV2, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxH264, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxAVC444, FALSE) || + !freerdp_settings_set_bool(settings, FreeRDP_GfxSendQoeAck, FALSE)) goto out_fail; + { + ARC_CS_PRIVATE_PACKET cookie = { 0 }; + if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ClientAutoReconnectCookie, &cookie, + sizeof(cookie))) + goto out_fail; + } + { + ARC_SC_PRIVATE_PACKET cookie = { 0 }; + if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerAutoReconnectCookie, &cookie, + sizeof(cookie))) + goto out_fail; + } settings->ClientTimeZone = (LPTIME_ZONE_INFORMATION)calloc(1, sizeof(TIME_ZONE_INFORMATION)); if (!settings->ClientTimeZone) goto out_fail; - settings->DeviceArraySize = 16; - settings->DeviceArray = - (RDPDR_DEVICE**)calloc(settings->DeviceArraySize, sizeof(RDPDR_DEVICE*)); + freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, 16); + settings->DeviceArray = (RDPDR_DEVICE**)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize), sizeof(RDPDR_DEVICE*)); if (!settings->DeviceArray) goto out_fail; - settings->StaticChannelArraySize = 16; - settings->StaticChannelArray = - (ADDIN_ARGV**)calloc(settings->StaticChannelArraySize, sizeof(ADDIN_ARGV*)); + freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, 16); + settings->StaticChannelArray = (ADDIN_ARGV**)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize), sizeof(ADDIN_ARGV*)); if (!settings->StaticChannelArray) goto out_fail; - settings->DynamicChannelArraySize = 16; + freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, 16); settings->DynamicChannelArray = - (ADDIN_ARGV**)calloc(settings->DynamicChannelArraySize, sizeof(ADDIN_ARGV*)); + (ADDIN_ARGV**)calloc(freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize), + sizeof(ADDIN_ARGV*)); if (!settings->DynamicChannelArray) goto out_fail; - settings->TcpKeepAlive = TRUE; - settings->TcpKeepAliveRetries = 3; - settings->TcpKeepAliveDelay = 5; - settings->TcpKeepAliveInterval = 2; - settings->TcpAckTimeout = 9000; + if (!freerdp_settings_set_bool(settings, FreeRDP_TcpKeepAlive, TRUE) || + !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveRetries, 3) || + !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveDelay, 5) || + !freerdp_settings_set_uint32(settings, FreeRDP_TcpKeepAliveInterval, 2) || + !freerdp_settings_set_uint32(settings, FreeRDP_TcpAckTimeout, 9000)) + goto out_fail; - if (!settings->ServerMode) + if (!freerdp_settings_get_bool(settings, FreeRDP_ServerMode)) { - settings->RedirectClipboard = TRUE; + BOOL rc; + char* path; + if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectClipboard, TRUE)) + goto out_fail; /* these values are used only by the client part */ - settings->HomePath = GetKnownPath(KNOWN_PATH_HOME); + path = GetKnownPath(KNOWN_PATH_HOME); + rc = freerdp_settings_set_string(settings, FreeRDP_HomePath, path); + free(path); - if (!settings->HomePath) + if (!rc || !freerdp_settings_get_string(settings, FreeRDP_HomePath)) goto out_fail; /* For default FreeRDP continue using same config directory @@ -568,37 +644,51 @@ rdpSettings* freerdp_settings_new(DWORD flags) * Custom builds use / as config folder. */ if (_stricmp(FREERDP_VENDOR_STRING, FREERDP_PRODUCT_STRING)) { + BOOL rc = TRUE; base = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, FREERDP_VENDOR_STRING); if (base) { - settings->ConfigPath = GetCombinedPath(base, FREERDP_PRODUCT_STRING); + char* combined = GetCombinedPath(base, FREERDP_PRODUCT_STRING); + rc = freerdp_settings_set_string(settings, FreeRDP_ConfigPath, combined); + free(combined); } free(base); + if (!rc) + goto out_fail; } else { + BOOL rc; size_t i; + char* path; char product[sizeof(FREERDP_PRODUCT_STRING)]; memset(product, 0, sizeof(product)); for (i = 0; i < sizeof(product); i++) product[i] = tolower(FREERDP_PRODUCT_STRING[i]); - settings->ConfigPath = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, product); + path = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, product); + rc = freerdp_settings_set_string(settings, FreeRDP_ConfigPath, path); + free(path); + if (!rc) + goto out_fail; } - if (!settings->ConfigPath) + if (!freerdp_settings_get_string(settings, FreeRDP_ConfigPath)) goto out_fail; } settings_load_hkey_local_machine(settings); - settings->ActionScript = _strdup("~/.config/freerdp/action.sh"); settings->XSelectionAtom = NULL; - settings->SmartcardLogon = FALSE; - settings->TlsSecLevel = 1; + if (!freerdp_settings_set_string(settings, FreeRDP_ActionScript, "~/.config/freerdp/action.sh")) + goto out_fail; + if (!freerdp_settings_set_bool(settings, FreeRDP_SmartcardLogon, FALSE)) + goto out_fail; + if (!freerdp_settings_set_uint32(settings, FreeRDP_TlsSecLevel, 1)) + goto out_fail; settings->OrderSupport = calloc(1, 32); if (!settings->OrderSupport) @@ -615,34 +705,12 @@ out_fail: static void freerdp_settings_free_internal(rdpSettings* settings) { - free(settings->ChannelDefArray); - free(settings->MonitorDefArray); - free(settings->MonitorIds); - free(settings->ReceivedCapabilities); - free(settings->OrderSupport); - free(settings->ServerRandom); - free(settings->ClientRandom); - free(settings->ServerCertificate); - certificate_free(settings->RdpServerCertificate); - free(settings->ClientAutoReconnectCookie); - free(settings->ServerAutoReconnectCookie); - free(settings->ClientTimeZone); - free(settings->BitmapCacheV2CellInfo); - free(settings->GlyphCache); - free(settings->FragCache); - key_free(settings->RdpServerRsaKey); - free(settings->LoadBalanceInfo); - free(settings->RedirectionPassword); - free(settings->RedirectionTsvUrl); - freerdp_target_net_addresses_free(settings); freerdp_device_collection_free(settings); freerdp_static_channel_collection_free(settings); freerdp_dynamic_channel_collection_free(settings); /* Extensions */ - free(settings->ActionScript); - settings->ActionScript = NULL; free(settings->XSelectionAtom); settings->XSelectionAtom = NULL; @@ -663,55 +731,31 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe { BOOL rc = FALSE; UINT32 index; + const void* data; + size_t len; if (!_settings || !settings) return FALSE; - if (settings->LoadBalanceInfo && settings->LoadBalanceInfoLength) - { - _settings->LoadBalanceInfo = (BYTE*)calloc(1, settings->LoadBalanceInfoLength + 2); + data = freerdp_settings_get_pointer(settings, FreeRDP_LoadBalanceInfo); + len = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength); + if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_LoadBalanceInfo, data, len)) + return FALSE; - if (!_settings->LoadBalanceInfo) - goto out_fail; + data = freerdp_settings_get_pointer(settings, FreeRDP_ServerRandom); + len = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength); + if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_ServerRandom, data, len)) + return FALSE; - CopyMemory(_settings->LoadBalanceInfo, settings->LoadBalanceInfo, - settings->LoadBalanceInfoLength); - _settings->LoadBalanceInfoLength = settings->LoadBalanceInfoLength; - } + data = freerdp_settings_get_pointer(settings, FreeRDP_ClientRandom); + len = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength); + if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_ClientRandom, data, len)) + return FALSE; - if (_settings->ServerRandomLength) - { - _settings->ServerRandom = (BYTE*)malloc(_settings->ServerRandomLength); - - if (!_settings->ServerRandom) - goto out_fail; - - CopyMemory(_settings->ServerRandom, settings->ServerRandom, settings->ServerRandomLength); - _settings->ServerRandomLength = settings->ServerRandomLength; - } - - if (_settings->ClientRandomLength) - { - _settings->ClientRandom = (BYTE*)malloc(_settings->ClientRandomLength); - - if (!_settings->ClientRandom) - goto out_fail; - - CopyMemory(_settings->ClientRandom, settings->ClientRandom, settings->ClientRandomLength); - _settings->ClientRandomLength = settings->ClientRandomLength; - } - - if (settings->ServerCertificateLength) - { - _settings->ServerCertificate = (BYTE*)malloc(settings->ServerCertificateLength); - - if (!_settings->ServerCertificate) - goto out_fail; - - CopyMemory(_settings->ServerCertificate, settings->ServerCertificate, - settings->ServerCertificateLength); - _settings->ServerCertificateLength = settings->ServerCertificateLength; - } + data = freerdp_settings_get_pointer(settings, FreeRDP_ServerCertificate); + len = freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength); + if (!freerdp_settings_set_pointer_len(_settings, FreeRDP_ServerCertificate, data, len)) + return FALSE; if (settings->RdpServerCertificate) { @@ -729,36 +773,46 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe goto out_fail; } - _settings->ChannelCount = settings->ChannelCount; - _settings->ChannelDefArraySize = settings->ChannelDefArraySize; + if (!freerdp_settings_set_uint32(_settings, FreeRDP_ChannelCount, + freerdp_settings_get_uint32(settings, FreeRDP_ChannelCount))) + goto out_fail; + if (!freerdp_settings_set_uint32( + _settings, FreeRDP_ChannelDefArraySize, + freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize))) + goto out_fail; - if (_settings->ChannelDefArraySize > 0) + if (freerdp_settings_get_uint32(_settings, FreeRDP_ChannelDefArraySize) > 0) { _settings->ChannelDefArray = - (CHANNEL_DEF*)calloc(settings->ChannelDefArraySize, sizeof(CHANNEL_DEF)); + (CHANNEL_DEF*)calloc(freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize), + sizeof(CHANNEL_DEF)); if (!_settings->ChannelDefArray) goto out_fail; CopyMemory(_settings->ChannelDefArray, settings->ChannelDefArray, - sizeof(CHANNEL_DEF) * settings->ChannelDefArraySize); + sizeof(CHANNEL_DEF) * + freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize)); } else _settings->ChannelDefArray = NULL; - _settings->MonitorCount = settings->MonitorCount; - _settings->MonitorDefArraySize = settings->MonitorDefArraySize; + freerdp_settings_set_uint32(_settings, FreeRDP_MonitorCount, + freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount)); + freerdp_settings_set_uint32(_settings, FreeRDP_MonitorDefArraySize, + freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize)); - if (_settings->MonitorDefArraySize > 0) + if (freerdp_settings_get_uint32(_settings, FreeRDP_MonitorDefArraySize) > 0) { - _settings->MonitorDefArray = - (rdpMonitor*)calloc(settings->MonitorDefArraySize, sizeof(rdpMonitor)); + _settings->MonitorDefArray = (rdpMonitor*)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize), sizeof(rdpMonitor)); if (!_settings->MonitorDefArray) goto out_fail; CopyMemory(_settings->MonitorDefArray, settings->MonitorDefArray, - sizeof(rdpMonitor) * settings->MonitorDefArraySize); + sizeof(rdpMonitor) * + freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize)); } else _settings->MonitorDefArray = NULL; @@ -806,22 +860,17 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe CopyMemory(_settings->GlyphCache, settings->GlyphCache, sizeof(GLYPH_CACHE_DEFINITION) * 10); CopyMemory(_settings->FragCache, settings->FragCache, sizeof(GLYPH_CACHE_DEFINITION)); - _settings->ClientAutoReconnectCookie = - (ARC_CS_PRIVATE_PACKET*)malloc(sizeof(ARC_CS_PRIVATE_PACKET)); - - if (!_settings->ClientAutoReconnectCookie) + if (!freerdp_settings_set_pointer_len( + _settings, FreeRDP_ClientAutoReconnectCookie, + freerdp_settings_get_pointer(settings, FreeRDP_ClientAutoReconnectCookie), + sizeof(ARC_CS_PRIVATE_PACKET))) + goto out_fail; + if (!freerdp_settings_set_pointer_len( + _settings, FreeRDP_ServerAutoReconnectCookie, + freerdp_settings_get_pointer(settings, FreeRDP_ServerAutoReconnectCookie), + sizeof(ARC_SC_PRIVATE_PACKET))) goto out_fail; - _settings->ServerAutoReconnectCookie = - (ARC_SC_PRIVATE_PACKET*)malloc(sizeof(ARC_SC_PRIVATE_PACKET)); - - if (!_settings->ServerAutoReconnectCookie) - goto out_fail; - - CopyMemory(_settings->ClientAutoReconnectCookie, settings->ClientAutoReconnectCookie, - sizeof(ARC_CS_PRIVATE_PACKET)); - CopyMemory(_settings->ServerAutoReconnectCookie, settings->ServerAutoReconnectCookie, - sizeof(ARC_SC_PRIVATE_PACKET)); _settings->ClientTimeZone = (LPTIME_ZONE_INFORMATION)malloc(sizeof(TIME_ZONE_INFORMATION)); if (!_settings->ClientTimeZone) @@ -829,18 +878,22 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe CopyMemory(_settings->ClientTimeZone, settings->ClientTimeZone, sizeof(TIME_ZONE_INFORMATION)); - _settings->RedirectionPasswordLength = settings->RedirectionPasswordLength; - if (settings->RedirectionPasswordLength > 0) + if (!freerdp_settings_set_uint32( + _settings, FreeRDP_RedirectionPasswordLength, + freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength))) + goto out_fail; + if (freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength) > 0) { - _settings->RedirectionPassword = malloc(_settings->RedirectionPasswordLength); + _settings->RedirectionPassword = + malloc(freerdp_settings_get_uint32(_settings, FreeRDP_RedirectionPasswordLength)); if (!_settings->RedirectionPassword) { - _settings->RedirectionPasswordLength = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_RedirectionPasswordLength, 0); goto out_fail; } CopyMemory(_settings->RedirectionPassword, settings->RedirectionPassword, - _settings->RedirectionPasswordLength); + freerdp_settings_get_uint32(_settings, FreeRDP_RedirectionPasswordLength)); } _settings->RedirectionTsvUrlLength = settings->RedirectionTsvUrlLength; @@ -857,20 +910,23 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe _settings->RedirectionTsvUrlLength); } - _settings->TargetNetAddressCount = settings->TargetNetAddressCount; + freerdp_settings_set_uint32( + _settings, FreeRDP_TargetNetAddressCount, + freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount)); - if (settings->TargetNetAddressCount > 0) + if (freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount) > 0) { - _settings->TargetNetAddresses = - (char**)calloc(settings->TargetNetAddressCount, sizeof(char*)); + _settings->TargetNetAddresses = (char**)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount), sizeof(char*)); if (!_settings->TargetNetAddresses) { - _settings->TargetNetAddressCount = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_TargetNetAddressCount, 0); goto out_fail; } - for (index = 0; index < settings->TargetNetAddressCount; index++) + for (index = 0; + index < freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount); index++) { _settings->TargetNetAddresses[index] = _strdup(settings->TargetNetAddresses[index]); @@ -881,40 +937,44 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe free(_settings->TargetNetAddresses); _settings->TargetNetAddresses = NULL; - _settings->TargetNetAddressCount = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_TargetNetAddressCount, 0); goto out_fail; } } if (settings->TargetNetPorts) { - _settings->TargetNetPorts = - (UINT32*)calloc(settings->TargetNetAddressCount, sizeof(UINT32)); + _settings->TargetNetPorts = (UINT32*)calloc( + freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount), + sizeof(UINT32)); if (!_settings->TargetNetPorts) goto out_fail; - for (index = 0; index < settings->TargetNetAddressCount; index++) + for (index = 0; + index < freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount); + index++) _settings->TargetNetPorts[index] = settings->TargetNetPorts[index]; } } _settings->DeviceCount = settings->DeviceCount; - _settings->DeviceArraySize = settings->DeviceArraySize; - _settings->DeviceArray = - (RDPDR_DEVICE**)calloc(_settings->DeviceArraySize, sizeof(RDPDR_DEVICE*)); + freerdp_settings_set_uint32(_settings, FreeRDP_DeviceArraySize, + freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize)); + _settings->DeviceArray = (RDPDR_DEVICE**)calloc( + freerdp_settings_get_uint32(_settings, FreeRDP_DeviceArraySize), sizeof(RDPDR_DEVICE*)); - if (!_settings->DeviceArray && _settings->DeviceArraySize) + if (!_settings->DeviceArray && freerdp_settings_get_uint32(_settings, FreeRDP_DeviceArraySize)) { _settings->DeviceCount = 0; - _settings->DeviceArraySize = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_DeviceArraySize, 0); goto out_fail; } - if (_settings->DeviceArraySize < _settings->DeviceCount) + if (freerdp_settings_get_uint32(_settings, FreeRDP_DeviceArraySize) < _settings->DeviceCount) { _settings->DeviceCount = 0; - _settings->DeviceArraySize = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_DeviceArraySize, 0); goto out_fail; } @@ -926,26 +986,33 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe goto out_fail; } - _settings->StaticChannelCount = settings->StaticChannelCount; - _settings->StaticChannelArraySize = settings->StaticChannelArraySize; + freerdp_settings_set_uint32(_settings, FreeRDP_StaticChannelCount, + freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount)); + freerdp_settings_set_uint32( + _settings, FreeRDP_StaticChannelArraySize, + freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize)); _settings->StaticChannelArray = - (ADDIN_ARGV**)calloc(_settings->StaticChannelArraySize, sizeof(ADDIN_ARGV*)); + (ADDIN_ARGV**)calloc(freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelArraySize), + sizeof(ADDIN_ARGV*)); - if (!_settings->StaticChannelArray && _settings->StaticChannelArraySize) + if (!_settings->StaticChannelArray && + freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelArraySize)) { - _settings->StaticChannelArraySize = 0; - _settings->ChannelCount = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_StaticChannelArraySize, 0); + freerdp_settings_set_uint32(_settings, FreeRDP_ChannelCount, 0); goto out_fail; } - if (_settings->StaticChannelArraySize < _settings->StaticChannelCount) + if (freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelArraySize) < + freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelCount)) { - _settings->StaticChannelArraySize = 0; - _settings->ChannelCount = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_StaticChannelArraySize, 0); + freerdp_settings_set_uint32(_settings, FreeRDP_ChannelCount, 0); goto out_fail; } - for (index = 0; index < _settings->StaticChannelCount; index++) + for (index = 0; index < freerdp_settings_get_uint32(_settings, FreeRDP_StaticChannelCount); + index++) { _settings->StaticChannelArray[index] = freerdp_static_channel_clone(settings->StaticChannelArray[index]); @@ -954,26 +1021,36 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe goto out_fail; } - _settings->DynamicChannelCount = settings->DynamicChannelCount; - _settings->DynamicChannelArraySize = settings->DynamicChannelArraySize; - _settings->DynamicChannelArray = - (ADDIN_ARGV**)calloc(_settings->DynamicChannelArraySize, sizeof(ADDIN_ARGV*)); + if (!freerdp_settings_set_uint32( + _settings, FreeRDP_DynamicChannelCount, + freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount)) || + !freerdp_settings_set_uint32( + _settings, FreeRDP_DynamicChannelArraySize, + freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize))) + goto out_fail; - if (!_settings->DynamicChannelArray && _settings->DynamicChannelArraySize) + _settings->DynamicChannelArray = (ADDIN_ARGV**)calloc( + freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelArraySize), + sizeof(ADDIN_ARGV*)); + + if (!_settings->DynamicChannelArray && + freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelArraySize)) { - _settings->DynamicChannelCount = 0; - _settings->DynamicChannelArraySize = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelCount, 0); + freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelArraySize, 0); goto out_fail; } - if (_settings->DynamicChannelArraySize < _settings->DynamicChannelCount) + if (freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelArraySize) < + freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelCount)) { - _settings->DynamicChannelCount = 0; - _settings->DynamicChannelArraySize = 0; + freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelCount, 0); + freerdp_settings_set_uint32(_settings, FreeRDP_DynamicChannelArraySize, 0); goto out_fail; } - for (index = 0; index < _settings->DynamicChannelCount; index++) + for (index = 0; index < freerdp_settings_get_uint32(_settings, FreeRDP_DynamicChannelCount); + index++) { _settings->DynamicChannelArray[index] = freerdp_dynamic_channel_clone(settings->DynamicChannelArray[index]); @@ -982,11 +1059,12 @@ static BOOL freerdp_settings_int_buffer_copy(rdpSettings* _settings, const rdpSe goto out_fail; } - if (settings->ActionScript) - _settings->ActionScript = _strdup(settings->ActionScript); + rc = freerdp_settings_set_string(_settings, FreeRDP_ActionScript, + freerdp_settings_get_string(settings, FreeRDP_ActionScript)); + if (settings->XSelectionAtom) _settings->XSelectionAtom = _strdup(settings->XSelectionAtom); - rc = TRUE; + out_fail: return rc; } @@ -1026,7 +1104,7 @@ BOOL freerdp_settings_copy(rdpSettings* _settings, const rdpSettings* settings) _settings->DeviceArray = NULL; _settings->StaticChannelArray = NULL; _settings->DynamicChannelArray = NULL; - _settings->ActionScript = NULL; + _settings->XSelectionAtom = NULL; if (!rc) goto out_fail; diff --git a/libfreerdp/core/settings.h b/libfreerdp/core/settings.h index d03369fd8..ac987dce6 100644 --- a/libfreerdp/core/settings.h +++ b/libfreerdp/core/settings.h @@ -21,15 +21,30 @@ #ifndef FREERDP_LIB_CORE_SETTINGS_H #define FREERDP_LIB_CORE_SETTINGS_H +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #include #include #include +#include + +#if !defined(HAVE_STRNDUP) +static INLINE char* strndup(const char* src, size_t len) +{ + char* dst = calloc(len + 1, sizeof(char)); + if (dst) + strncpy(dst, src, len); + return dst; +} +#endif + FREERDP_LOCAL BOOL freerdp_settings_set_default_order_support(rdpSettings* settings); -FREERDP_LOCAL BOOL freerdp_settings_set_pointer(rdpSettings* dst, size_t index, const void* ptr); FREERDP_LOCAL BOOL freerdp_settings_clone_keys(rdpSettings* dst, const rdpSettings* src); FREERDP_LOCAL void freerdp_settings_free_keys(rdpSettings* dst, BOOL cleanup); FREERDP_LOCAL BOOL freerdp_settings_set_string_(rdpSettings* settings, size_t id, const char* val, - BOOL cleanup); + size_t len, BOOL cleanup); #endif /* FREERDP_LIB_CORE_SETTINGS_H */ diff --git a/libfreerdp/core/test/settings_property_lists.h b/libfreerdp/core/test/settings_property_lists.h index a4b1ecb7e..7bafcc222 100644 --- a/libfreerdp/core/test/settings_property_lists.h +++ b/libfreerdp/core/test/settings_property_lists.h @@ -212,6 +212,7 @@ static const size_t uint32_list_indices[] = { FreeRDP_EncryptionLevel, FreeRDP_EncryptionMethods, FreeRDP_ExtEncryptionMethods, + FreeRDP_Floatbar, FreeRDP_FrameAcknowledge, FreeRDP_GatewayAcceptedCertLength, FreeRDP_GatewayCredentialsSource, @@ -285,6 +286,7 @@ static const size_t uint32_list_indices[] = { FreeRDP_TcpKeepAliveDelay, FreeRDP_TcpKeepAliveInterval, FreeRDP_TcpKeepAliveRetries, + FreeRDP_ThreadingFlags, FreeRDP_TlsSecLevel, FreeRDP_VirtualChannelChunkSize, FreeRDP_VirtualChannelCompressionFlags, @@ -304,6 +306,7 @@ static const size_t uint64_list_indices[] = { #define have_string_list_indices static const size_t string_list_indices[] = { FreeRDP_AcceptedCert, + FreeRDP_ActionScript, FreeRDP_AllowedTlsCiphers, FreeRDP_AlternateShell, FreeRDP_AssistanceFile, diff --git a/scripts/update-settings-tests b/scripts/update-settings-tests index 0d7f3db71..3d3ed6208 100755 --- a/scripts/update-settings-tests +++ b/scripts/update-settings-tests @@ -110,7 +110,9 @@ def write_str(f, entry_dict): f.write('\t\t\tcase 7: /* strings */\n') f.write('\t\t\t{\n') f.write('\t\t\t\tconst char* sval = freerdp_settings_get_string(src, cur->id);\n') - f.write('\t\t\t\tif (!freerdp_settings_set_string_(dst, cur->id, sval, FALSE))\n') + f.write('\t\t\t\t\tsize_t len = 0;\n') + f.write('\t\t\t\t\tif (sval) len = strlen(sval);\n') + f.write('\t\t\t\tif (!freerdp_settings_set_string_(dst, cur->id, sval, len, FALSE))\n') f.write('\t\t\t\t\treturn FALSE;\n') f.write('\t\t\t}\n') f.write('\t\t\tbreak;\n') @@ -204,10 +206,10 @@ def write_str(f, entry_dict): f.write('\t\tswitch(cur->type)\n') f.write('\t\t{\n') f.write('\t\t\tcase 7: /* strings */\n') - f.write('\t\t\t\tfreerdp_settings_set_string_(dst, cur->id, NULL, cleanup);\n') + f.write('\t\t\t\tfreerdp_settings_set_string_(dst, cur->id, NULL, 0, cleanup);\n') f.write('\t\t\tbreak;\n') f.write('\t\t\tcase 8: /* pointer */\n') - f.write('\t\t\t\tfreerdp_settings_set_pointer(dst, cur->id, NULL);\n') + f.write('\t\t\t\tfreerdp_settings_set_pointer_len(dst, cur->id, NULL, 0);\n') f.write('\t\t\tbreak;\n') f.write('\t\t}\n') f.write('\t}\n') @@ -273,12 +275,15 @@ def write_getter(f, entry_dict, entry_type, entry_name): values = get_values(entry_dict, entry_type) if isPointer: - f.write('const void*') + f.write('void*') elif isString: f.write('const ' + entry_type) else: f.write(entry_type) - f.write(' freerdp_settings_get_' + entry_name.lower() + '(const rdpSettings* settings, size_t id)\n') + if isPointer: + f.write(' freerdp_settings_get_pointer_writable(const rdpSettings* settings, size_t id)\n') + else: + f.write(' freerdp_settings_get_' + entry_name.lower() + '(const rdpSettings* settings, size_t id)\n') f.write('{\n') f.write('\tif (!settings)\n') f.write('\t\treturn FALSE;\n\n') @@ -304,7 +309,7 @@ def write_setter_case(f, val, isString, isPointer): else: f.write('\t\t\tif (cleanup)\n') f.write('\t\t\t\tfree(settings->' + val + ');\n') - f.write('\t\t\tsettings->' + val + ' = (val ? _strdup(val) : NULL);\n') + f.write('\t\t\tsettings->' + val + ' = (val ? strndup(val, len) : NULL);\n') f.write('\t\t\treturn (!val || settings->' + val + ' != NULL);\n\n') def write_setter(f, entry_dict, entry_type, entry_name): @@ -323,7 +328,7 @@ def write_setter(f, entry_dict, entry_type, entry_name): else: f.write('void* val') if isString: - f.write(', BOOL cleanup)\n') + f.write(', size_t len, BOOL cleanup)\n') else: f.write(')\n') f.write('{\n') @@ -342,16 +347,17 @@ def write_setter(f, entry_dict, entry_type, entry_name): f.write('}\n\n') f.write('\n') if isString: - f.write('BOOL freerdp_settings_set_' + entry_name.lower() + '(rdpSettings* settings, size_t id, ') - if isString or isPointer: - f.write('const ') - if not isPointer: - f.write(entry_type + ' val') - else: - f.write('void* val') - f.write(')\n') + f.write('BOOL freerdp_settings_set_string_len(rdpSettings* settings, size_t id, const char* val, size_t len)\n') f.write('{\n') - f.write('\treturn freerdp_settings_set_' + entry_name.lower() + '_(settings, id, val, TRUE);\n') + f.write('\treturn freerdp_settings_set_string_(settings, id, val, len, TRUE);\n') + f.write('}\n') + f.write('\n') + + f.write('BOOL freerdp_settings_set_string(rdpSettings* settings, size_t id, const char* val)\n') + f.write('{\n') + f.write('\tsize_t len = 0;\n') + f.write('\tif (val) len = strlen(val);\n') + f.write('\treturn freerdp_settings_set_string_(settings, id, val, len, TRUE);\n') f.write('}\n') f.write('\n') @@ -399,6 +405,7 @@ try: f.write('/* Generated by ' + '' + ' */\n\n') f.write('#include \n') f.write('#include \n\n') + f.write('#include "../core/settings.h"\n\n') f.write('#define TAG FREERDP_TAG("common.settings")\n\n') getter_list = dict(type_list)