23#include <freerdp/config.h>
32#include <winpr/assert.h>
33#include <winpr/cast.h>
35#include "../core/settings.h"
36#include "../core/capabilities.h"
38#include <freerdp/crypto/certificate.h>
39#include <freerdp/settings.h>
40#include <freerdp/freerdp.h>
41#include <freerdp/log.h>
43#define TAG FREERDP_TAG("common")
45BOOL freerdp_addin_argv_add_argument_ex(
ADDIN_ARGV* args,
const char* argument,
size_t len)
47 if (!args || !argument)
51 len = strlen(argument);
53 char** new_argv = (
char**)realloc(
54 (
void*)args->argv,
sizeof(
char*) * (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc) + 1));
59 args->argv = new_argv;
61 char* str = calloc(len + 1,
sizeof(
char));
64 memcpy(str, argument, len);
65 args->argv[args->argc++] = str;
69BOOL freerdp_addin_argv_add_argument(
ADDIN_ARGV* args,
const char* argument)
71 return freerdp_addin_argv_add_argument_ex(args, argument, 0);
74BOOL freerdp_addin_argv_del_argument(
ADDIN_ARGV* args,
const char* argument)
76 if (!args || !argument)
78 for (
int x = 0; x < args->argc; x++)
80 char* arg = args->argv[x];
81 if (strcmp(argument, arg) == 0)
84 memmove_s((
void*)&args->argv[x],
85 (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc - x)) *
sizeof(
char*),
86 (
void*)&args->argv[x + 1],
87 (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc - x - 1)) *
sizeof(
char*));
88 args->argv[args->argc - 1] = NULL;
96int freerdp_addin_set_argument(
ADDIN_ARGV* args,
const char* argument)
98 if (!args || !argument)
101 for (
int i = 0; i < args->argc; i++)
103 if (strcmp(args->argv[i], argument) == 0)
109 if (!freerdp_addin_argv_add_argument(args, argument))
114int freerdp_addin_replace_argument(
ADDIN_ARGV* args,
const char* previous,
const char* argument)
116 if (!args || !previous || !argument)
119 for (
int i = 0; i < args->argc; i++)
121 if (strcmp(args->argv[i], previous) == 0)
125 if (!(args->argv[i] = _strdup(argument)))
132 if (!freerdp_addin_argv_add_argument(args, argument))
137int freerdp_addin_set_argument_value(
ADDIN_ARGV* args,
const char* option,
const char* value)
143 if (!args || !option || !value)
145 length = strlen(option) + strlen(value) + 1;
146 str = (
char*)calloc(length + 1,
sizeof(
char));
151 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
153 for (
int i = 0; i < args->argc; i++)
155 p = strchr(args->argv[i],
':');
159 if (strncmp(args->argv[i], option,
160 WINPR_ASSERTING_INT_CAST(
size_t, p - args->argv[i])) == 0)
169 rc = freerdp_addin_argv_add_argument(args, str);
176int freerdp_addin_replace_argument_value(
ADDIN_ARGV* args,
const char* previous,
const char* option,
182 if (!args || !previous || !option || !value)
184 length = strlen(option) + strlen(value) + 1;
185 str = (
char*)calloc(length + 1,
sizeof(
char));
190 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
192 for (
int i = 0; i < args->argc; i++)
194 if (strcmp(args->argv[i], previous) == 0)
202 rc = freerdp_addin_argv_add_argument(args, str);
209BOOL freerdp_device_collection_add(rdpSettings* settings,
RDPDR_DEVICE* device)
213 WINPR_ASSERT(settings);
214 WINPR_ASSERT(device);
220 const size_t new_size = (old + 32);
227 settings->DeviceArray = new_array;
228 for (
size_t x = old; x < new_size; x++)
229 settings->DeviceArray[x] = NULL;
232 WINPR_ASSERTING_INT_CAST(uint32_t, new_size)))
236 settings->DeviceArray[settings->DeviceCount++] = device;
242 WINPR_ASSERT(settings);
247 const UINT32 count = settings->DeviceCount;
248 for (
size_t x = 0; x < count; x++)
253 for (
size_t y = x + 1; y < count; y++)
256 settings->DeviceArray[y - 1] = next;
258 settings->DeviceArray[count - 1] = NULL;
259 settings->DeviceCount--;
267RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings,
const char* name)
271 WINPR_ASSERT(settings);
273 for (UINT32 index = 0; index < settings->DeviceCount; index++)
275 device = settings->DeviceArray[index];
280 if (strcmp(device->Name, name) == 0)
287RDPDR_DEVICE* freerdp_device_collection_find_type(rdpSettings* settings, UINT32 type)
290 WINPR_ASSERT(settings);
292 for (UINT32 index = 0; index < settings->DeviceCount; index++)
294 device = settings->DeviceArray[index];
296 if (device->Type == type)
303RDPDR_DEVICE* freerdp_device_new(UINT32 Type,
size_t count,
const char*
const args[])
317 WINPR_ASSERT(args || (count == 0));
321 case RDPDR_DTYP_PRINT:
324 case RDPDR_DTYP_SERIAL:
327 case RDPDR_DTYP_PARALLEL:
330 case RDPDR_DTYP_SMARTCARD:
333 case RDPDR_DTYP_FILESYSTEM:
340 device.base = calloc(1, size);
344 device.base->Type = Type;
348 device.base->Name = _strdup(args[0]);
349 if (!device.base->Name)
354 case RDPDR_DTYP_PRINT:
357 device.printer->DriverName = _strdup(args[1]);
358 if (!device.printer->DriverName)
364 device.printer->IsDefault = _stricmp(args[2],
"default") == 0;
367 case RDPDR_DTYP_SERIAL:
370 device.serial->Path = _strdup(args[1]);
371 if (!device.serial->Path)
377 device.serial->Driver = _strdup(args[2]);
378 if (!device.serial->Driver)
384 device.serial->Permissive = _strdup(args[3]);
385 if (!device.serial->Permissive)
389 case RDPDR_DTYP_PARALLEL:
392 device.parallel->Path = _strdup(args[1]);
393 if (!device.serial->Path)
397 case RDPDR_DTYP_SMARTCARD:
399 case RDPDR_DTYP_FILESYSTEM:
402 device.drive->Path = _strdup(args[1]);
403 if (!device.drive->Path)
407 device.drive->automount = (args[2] == NULL) ? TRUE : FALSE;
416 freerdp_device_free(device.base);
437 switch (device->Type)
439 case RDPDR_DTYP_PRINT:
440 free(cnv.printer->DriverName);
442 case RDPDR_DTYP_SERIAL:
443 free(cnv.serial->Path);
444 free(cnv.serial->Driver);
445 free(cnv.serial->Permissive);
447 case RDPDR_DTYP_PARALLEL:
448 free(cnv.parallel->Path);
450 case RDPDR_DTYP_SMARTCARD:
452 case RDPDR_DTYP_FILESYSTEM:
453 free(cnv.drive->Path);
484 const char* args[4] = { 0 };
494 args[count++] = device->Name;
497 switch (device->Type)
499 case RDPDR_DTYP_FILESYSTEM:
502 args[count++] = src.drive->Path;
503 args[count++] = src.drive->automount ? NULL : src.drive->Path;
507 case RDPDR_DTYP_PRINT:
508 if (src.printer->DriverName)
509 args[count++] = src.printer->DriverName;
512 case RDPDR_DTYP_SMARTCARD:
515 case RDPDR_DTYP_SERIAL:
516 if (src.serial->Path)
517 args[count++] = src.serial->Path;
519 if (src.serial->Driver)
520 args[count++] = src.serial->Driver;
522 if (src.serial->Permissive)
523 args[count++] = src.serial->Permissive;
526 case RDPDR_DTYP_PARALLEL:
527 if (src.parallel->Path)
528 args[count++] = src.parallel->Path;
531 WLog_ERR(TAG,
"unknown device type %" PRIu32
"", device->Type);
535 copy.dev = freerdp_device_new(device->Type, count, args);
539 copy.dev->Id = device->Id;
544void freerdp_device_collection_free(rdpSettings* settings)
546 WINPR_ASSERT(settings);
548 if (settings->DeviceArray)
550 for (UINT32 index = 0; index < settings->DeviceArraySize; index++)
551 (
void)freerdp_settings_set_pointer_array(settings, FreeRDP_DeviceArray, index, NULL);
554 free((
void*)settings->DeviceArray);
561BOOL freerdp_static_channel_collection_del(rdpSettings* settings,
const char* name)
564 if (!settings || !settings->StaticChannelArray)
567 for (UINT32 x = 0; x < count; x++)
569 ADDIN_ARGV* cur = settings->StaticChannelArray[x];
570 if (cur && (cur->argc > 0))
572 if (strcmp(name, cur->argv[0]) == 0)
574 memmove_s((
void*)&settings->StaticChannelArray[x],
576 (
void*)&settings->StaticChannelArray[x + 1],
578 for (
size_t y = count - 1; y < settings->StaticChannelArraySize; y++)
579 settings->StaticChannelArray[y] = NULL;
581 freerdp_addin_argv_free(cur);
587 for (
size_t x = count; x < settings->StaticChannelArraySize; x++)
588 settings->StaticChannelArray[x] = NULL;
593BOOL freerdp_static_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
597 WINPR_ASSERT(settings);
598 WINPR_ASSERT(channel);
603 const UINT32 oldSize =
605 const size_t new_size = oldSize + 32ul;
612 settings->StaticChannelArray = new_array;
614 for (
size_t x = oldSize; x < new_size; x++)
615 settings->StaticChannelArray[x] = NULL;
618 WINPR_ASSERTING_INT_CAST(uint32_t, new_size)))
624 ADDIN_ARGV** cur = &settings->StaticChannelArray[count++];
625 freerdp_addin_argv_free(*cur);
630ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings,
const char* name)
634 WINPR_ASSERT(settings);
637 for (UINT32 index = 0;
640 channel = settings->StaticChannelArray[index];
642 if (strcmp(channel->argv[0], name) == 0)
649void freerdp_static_channel_collection_free(rdpSettings* settings)
654 if (settings->StaticChannelArray)
658 freerdp_addin_argv_free(settings->StaticChannelArray[i]);
661 free((
void*)settings->StaticChannelArray);
663 settings->StaticChannelArray = NULL;
667BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings,
const char* name)
670 if (!settings || !settings->DynamicChannelArray)
673 for (UINT32 x = 0; x < count; x++)
675 ADDIN_ARGV* cur = settings->DynamicChannelArray[x];
676 if (cur && (cur->argc > 0))
678 if (strcmp(name, cur->argv[0]) == 0)
680 memmove_s((
void*)&settings->DynamicChannelArray[x],
682 (
void*)&settings->DynamicChannelArray[x + 1],
684 for (
size_t y = count - 1; y < settings->DynamicChannelArraySize; y++)
685 settings->DynamicChannelArray[y] = NULL;
687 freerdp_addin_argv_free(cur);
697BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
702 WINPR_ASSERT(settings);
703 WINPR_ASSERT(channel);
710 const size_t size = oldSize + 32;
717 settings->DynamicChannelArray = new_array;
719 for (
size_t x = oldSize; x < size; x++)
720 settings->DynamicChannelArray[x] = NULL;
723 WINPR_ASSERTING_INT_CAST(uint32_t, size)))
728 settings->DynamicChannelArray[count++] = channel;
732ADDIN_ARGV* freerdp_dynamic_channel_collection_find(
const rdpSettings* settings,
const char* name)
734 WINPR_ASSERT(settings);
737 for (UINT32 index = 0;
740 ADDIN_ARGV* channel = settings->DynamicChannelArray[index];
742 if (strcmp(channel->argv[0], name) == 0)
756 for (
int index = 0; index < args->argc; index++)
757 free(args->argv[index]);
758 free((
void*)args->argv);
764ADDIN_ARGV* freerdp_addin_argv_new(
size_t argc,
const char*
const argv[])
766 if (argc > INT32_MAX)
775 args->argc = (int)argc;
776 args->argv = (
char**)calloc(argc,
sizeof(
char*));
782 for (
size_t x = 0; x < argc; x++)
784 args->argv[x] = _strdup(argv[x]);
792 WINPR_PRAGMA_DIAG_PUSH
793 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
794 freerdp_addin_argv_free(args);
795 WINPR_PRAGMA_DIAG_POP
809 return freerdp_addin_argv_new(WINPR_ASSERTING_INT_CAST(uint32_t, args->argc), cnv.cc);
812void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
814 WINPR_ASSERT(settings);
816 if (settings->DynamicChannelArray)
820 freerdp_addin_argv_free(settings->DynamicChannelArray[i]);
823 free((
void*)settings->DynamicChannelArray);
825 settings->DynamicChannelArray = NULL;
829static void freerdp_capability_data_free(rdpSettings* settings,
size_t offset, BOOL full)
831 WINPR_ASSERT(settings);
833 if (settings->ReceivedCapabilityData)
835 for (
size_t x = offset; x < settings->ReceivedCapabilitiesSize; x++)
837 free(settings->ReceivedCapabilityData[x]);
838 settings->ReceivedCapabilityData[x] = NULL;
842 free((
void*)settings->ReceivedCapabilityData);
843 settings->ReceivedCapabilityData = NULL;
848void freerdp_capability_buffer_free(rdpSettings* settings)
850 WINPR_ASSERT(settings);
852 freerdp_capability_data_free(settings, 0, TRUE);
854 free(settings->ReceivedCapabilityDataSizes);
855 settings->ReceivedCapabilityDataSizes = NULL;
857 free(settings->ReceivedCapabilities);
858 settings->ReceivedCapabilities = NULL;
860 settings->ReceivedCapabilitiesSize = 0;
863static BOOL resize_setting(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
size_t oldsize,
864 size_t size,
size_t base)
867 uint8_t* ptr = realloc(old, size * base);
873 const size_t diff = size - oldsize;
874 memset(&ptr[oldsize * base], 0, diff * base);
881static BOOL resize_setting_ptr(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
882 size_t oldsize,
size_t size,
size_t base)
884 WINPR_ASSERT(base ==
sizeof(
void*));
889 uint8_t** optr = WINPR_REINTERPRET_CAST(old, uint8_t*, uint8_t**);
890 for (
size_t x = size; x < oldsize; x++)
892 uint8_t* ptr = optr[x];
896 uint8_t* ptr = realloc(old, size * base);
900 uint8_t** optr = WINPR_REINTERPRET_CAST(ptr, uint8_t*, uint8_t**);
901 for (
size_t x = oldsize; x < size; x++)
910BOOL freerdp_capability_buffer_resize(rdpSettings* settings,
size_t count, BOOL force)
912 WINPR_ASSERT(settings);
914 const uint32_t len = settings->ReceivedCapabilitiesSize;
921 freerdp_capability_data_free(settings, count, FALSE);
925 freerdp_capability_buffer_free(settings);
929 const size_t oldsize = settings->ReceivedCapabilitiesSize;
930 if (!resize_setting(settings, FreeRDP_ReceivedCapabilityDataSizes, oldsize, count,
933 if (!resize_setting_ptr(settings, FreeRDP_ReceivedCapabilityData, oldsize, count,
936 if (!resize_setting(settings, FreeRDP_ReceivedCapabilities, oldsize, count,
sizeof(uint32_t)))
939 settings->ReceivedCapabilitiesSize = WINPR_ASSERTING_INT_CAST(uint32_t, count);
943BOOL freerdp_capability_buffer_copy(rdpSettings* settings,
const rdpSettings* src)
945 WINPR_ASSERT(settings);
948 if (src->ReceivedCapabilitiesSize == 0)
951 if (!freerdp_capability_buffer_resize(settings, src->ReceivedCapabilitiesSize, TRUE))
954 for (UINT32 x = 0; x < src->ReceivedCapabilitiesSize; x++)
956 WINPR_ASSERT(settings->ReceivedCapabilities);
957 settings->ReceivedCapabilities[x] = src->ReceivedCapabilities[x];
959 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
960 settings->ReceivedCapabilityDataSizes[x] = src->ReceivedCapabilityDataSizes[x];
962 WINPR_ASSERT(settings->ReceivedCapabilityData);
963 if (src->ReceivedCapabilityDataSizes[x] > 0)
965 void* tmp = realloc(settings->ReceivedCapabilityData[x],
966 settings->ReceivedCapabilityDataSizes[x]);
969 memcpy(tmp, src->ReceivedCapabilityData[x], src->ReceivedCapabilityDataSizes[x]);
970 settings->ReceivedCapabilityData[x] = tmp;
974 free(settings->ReceivedCapabilityData[x]);
975 settings->ReceivedCapabilityData[x] = NULL;
981static void target_net_addresses_free(rdpSettings* settings,
size_t offset)
983 WINPR_ASSERT(settings);
985 if (settings->TargetNetAddresses)
987 for (
size_t index = offset; index < settings->TargetNetAddressCount; index++)
989 free(settings->TargetNetAddresses[index]);
990 settings->TargetNetAddresses[index] = NULL;
995void freerdp_target_net_addresses_free(rdpSettings* settings)
997 WINPR_ASSERT(settings);
999 target_net_addresses_free(settings, 0);
1001 free((
void*)settings->TargetNetAddresses);
1002 settings->TargetNetAddresses = NULL;
1004 free(settings->TargetNetPorts);
1005 settings->TargetNetPorts = NULL;
1007 settings->TargetNetAddressCount = 0;
1010BOOL freerdp_target_net_addresses_resize(rdpSettings* settings,
size_t count)
1012 WINPR_ASSERT(settings);
1016 freerdp_target_net_addresses_free(settings);
1020 const uint32_t len = settings->TargetNetAddressCount;
1021 if (!resize_setting_ptr(settings, FreeRDP_TargetNetAddresses, len, count,
sizeof(
char*)))
1023 if (!resize_setting(settings, FreeRDP_TargetNetPorts, len, count,
sizeof(uint32_t)))
1026 settings->TargetNetAddressCount = WINPR_ASSERTING_INT_CAST(uint32_t, count);
1030void freerdp_server_license_issuers_free(rdpSettings* settings)
1032 WINPR_ASSERT(settings);
1034 if (settings->ServerLicenseProductIssuers)
1036 for (UINT32 x = 0; x < settings->ServerLicenseProductIssuersCount; x++)
1037 free(settings->ServerLicenseProductIssuers[x]);
1039 free((
void*)settings->ServerLicenseProductIssuers);
1040 settings->ServerLicenseProductIssuers = NULL;
1041 settings->ServerLicenseProductIssuersCount = 0;
1044BOOL freerdp_server_license_issuers_copy(rdpSettings* settings,
char** issuers, UINT32 count)
1046 WINPR_ASSERT(settings);
1047 WINPR_ASSERT(issuers || (count == 0));
1053 for (UINT32 x = 0; x < count; x++)
1055 char* issuer = _strdup(issuers[x]);
1058 settings->ServerLicenseProductIssuers[x] = issuer;
1064void freerdp_performance_flags_make(rdpSettings* settings)
1066 UINT32 PerformanceFlags = PERF_FLAG_NONE;
1069 PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING;
1072 PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION;
1075 PerformanceFlags |= PERF_DISABLE_WALLPAPER;
1078 PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG;
1081 PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS;
1084 PerformanceFlags |= PERF_DISABLE_THEMING;
1088void freerdp_performance_flags_split(rdpSettings* settings)
1091 settings, FreeRDP_AllowFontSmoothing,
1093 PERF_ENABLE_FONT_SMOOTHING)
1097 settings, FreeRDP_AllowDesktopComposition,
1099 PERF_ENABLE_DESKTOP_COMPOSITION)
1103 settings, FreeRDP_DisableWallpaper,
1108 settings, FreeRDP_DisableFullWindowDrag,
1110 PERF_DISABLE_FULLWINDOWDRAG)
1114 settings, FreeRDP_DisableMenuAnims,
1116 PERF_DISABLE_MENUANIMATIONS)
1120 settings, FreeRDP_DisableThemes,
1131 if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT)
1137 else if (GatewayUsageMethod == TSC_PROXY_MODE_DIRECT)
1143 else if (GatewayUsageMethod == TSC_PROXY_MODE_DETECT)
1149 else if (GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT)
1160 else if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT)
1170void freerdp_update_gateway_usage_method(rdpSettings* settings, UINT32 GatewayEnabled,
1171 UINT32 GatewayBypassLocal)
1173 UINT32 GatewayUsageMethod = 0;
1175 if (!GatewayEnabled && !GatewayBypassLocal)
1176 GatewayUsageMethod = TSC_PROXY_MODE_NONE_DIRECT;
1177 else if (GatewayEnabled && !GatewayBypassLocal)
1178 GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
1179 else if (GatewayEnabled && GatewayBypassLocal)
1180 GatewayUsageMethod = TSC_PROXY_MODE_DETECT;
1185#if defined(WITH_FREERDP_DEPRECATED)
1186BOOL freerdp_get_param_bool(
const rdpSettings* settings,
int id)
1191int freerdp_set_param_bool(rdpSettings* settings,
int id, BOOL param)
1196int freerdp_get_param_int(
const rdpSettings* settings,
int id)
1201int freerdp_set_param_int(rdpSettings* settings,
int id,
int param)
1206UINT32 freerdp_get_param_uint32(
const rdpSettings* settings,
int id)
1211int freerdp_set_param_uint32(rdpSettings* settings,
int id, UINT32 param)
1216UINT64 freerdp_get_param_uint64(
const rdpSettings* settings,
int id)
1221int freerdp_set_param_uint64(rdpSettings* settings,
int id, UINT64 param)
1226char* freerdp_get_param_string(
const rdpSettings* settings,
int id)
1229 return WINPR_CAST_CONST_PTR_AWAY(str,
char*);
1232int freerdp_set_param_string(rdpSettings* settings,
int id,
const char* param)
1238static BOOL value_to_uint(
const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
1240 char* endptr = NULL;
1241 unsigned long long rc = 0;
1243 if (!value || !result)
1247 rc = _strtoui64(value, &endptr, 0);
1252 if (endptr == value)
1255 if ((rc < min) || (rc > max))
1262static BOOL value_to_int(
const char* value, LONGLONG* result, LONGLONG min, LONGLONG max)
1264 char* endptr = NULL;
1267 if (!value || !result)
1271 rc = _strtoi64(value, &endptr, 0);
1276 if (endptr == value)
1279 if ((rc < min) || (rc > max))
1286static BOOL parsing_fail(
const char* key,
const char* type,
const char* value)
1288 WLog_ERR(TAG,
"Failed to parse key [%s] of type [%s]: value [%s]", key, type, value);
1292BOOL freerdp_settings_set_value_for_name(rdpSettings* settings,
const char* name,
const char* value)
1298 if (!settings || !name)
1304 WLog_ERR(TAG,
"Invalid settings key [%s]", name);
1308 const SSIZE_T index = i;
1314 case RDP_SETTINGS_TYPE_BOOL:
1316 const BOOL val = (_strnicmp(value,
"TRUE", 5) == 0) || (_strnicmp(value,
"ON", 5) == 0);
1318 (_strnicmp(value,
"FALSE", 6) == 0) || (_strnicmp(value,
"OFF", 6) == 0);
1320 return parsing_fail(name,
"BOOL", value);
1325 case RDP_SETTINGS_TYPE_UINT16:
1326 if (!value_to_uint(value, &uval, 0, UINT16_MAX))
1327 return parsing_fail(name,
"UINT16", value);
1332 return parsing_fail(name,
"UINT16", value);
1335 case RDP_SETTINGS_TYPE_INT16:
1336 if (!value_to_int(value, &ival, INT16_MIN, INT16_MAX))
1337 return parsing_fail(name,
"INT16", value);
1342 return parsing_fail(name,
"INT16", value);
1344 case RDP_SETTINGS_TYPE_UINT32:
1345 if (!value_to_uint(value, &uval, 0, UINT32_MAX))
1346 return parsing_fail(name,
"UINT32", value);
1351 return parsing_fail(name,
"UINT32", value);
1353 case RDP_SETTINGS_TYPE_INT32:
1354 if (!value_to_int(value, &ival, INT32_MIN, INT32_MAX))
1355 return parsing_fail(name,
"INT32", value);
1360 return parsing_fail(name,
"INT32", value);
1362 case RDP_SETTINGS_TYPE_UINT64:
1363 if (!value_to_uint(value, &uval, 0, UINT64_MAX))
1364 return parsing_fail(name,
"UINT64", value);
1368 return parsing_fail(name,
"UINT64", value);
1370 case RDP_SETTINGS_TYPE_INT64:
1371 if (!value_to_int(value, &ival, INT64_MIN, INT64_MAX))
1372 return parsing_fail(name,
"INT64", value);
1376 return parsing_fail(name,
"INT64", value);
1379 case RDP_SETTINGS_TYPE_STRING:
1383 case RDP_SETTINGS_TYPE_POINTER:
1384 return parsing_fail(name,
"POINTER", value);
1391BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1392 FreeRDP_Settings_Keys_UInt32 lenId,
const void* data,
1393 size_t len,
size_t size)
1401 if (lenId != FreeRDP_UINT32_UNUSED)
1407 if (len > UINT32_MAX)
1411 copy = calloc(len, size);
1415 memcpy(copy, data, len * size);
1425 if (lenId == FreeRDP_UINT32_UNUSED)
1431 FreeRDP_Settings_Keys_Pointer
id)
1435 const rdpSettings* pc;
1443 const void* data,
size_t len)
1457 case FreeRDP_RdpServerCertificate:
1458 freerdp_certificate_free(settings->RdpServerCertificate);
1462 WLog_ERR(TAG,
"FreeRDP_RdpServerCertificate::len must be 0 or 1");
1465 settings->RdpServerCertificate = cnv.v;
1466 if (!settings->RdpServerCertificate && (len > 0))
1468 settings->RdpServerCertificate = freerdp_certificate_new();
1469 if (!settings->RdpServerCertificate)
1473 case FreeRDP_RdpServerRsaKey:
1474 freerdp_key_free(settings->RdpServerRsaKey);
1477 WLog_ERR(TAG,
"FreeRDP_RdpServerRsaKey::len must be 0 or 1");
1480 settings->RdpServerRsaKey = (rdpPrivateKey*)cnv.v;
1481 if (!settings->RdpServerRsaKey && (len > 0))
1483 settings->RdpServerRsaKey = freerdp_key_new();
1484 if (!settings->RdpServerRsaKey)
1488 case FreeRDP_RedirectionPassword:
1489 return freerdp_settings_set_pointer_len_(
1490 settings,
id, FreeRDP_RedirectionPasswordLength, data, len,
sizeof(
char));
1491 case FreeRDP_RedirectionTsvUrl:
1492 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionTsvUrlLength,
1493 data, len,
sizeof(
char));
1494 case FreeRDP_RedirectionTargetCertificate:
1495 freerdp_certificate_free(settings->RedirectionTargetCertificate);
1499 WLog_ERR(TAG,
"FreeRDP_RedirectionTargetCertificate::len must be 0 or 1");
1502 settings->RedirectionTargetCertificate = cnv.v;
1503 if (!settings->RedirectionTargetCertificate && (len > 0))
1505 settings->RedirectionTargetCertificate = freerdp_certificate_new();
1506 if (!settings->RedirectionTargetCertificate)
1510 case FreeRDP_RedirectionGuid:
1511 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionGuidLength,
1512 data, len,
sizeof(BYTE));
1513 case FreeRDP_LoadBalanceInfo:
1514 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_LoadBalanceInfoLength,
1515 data, len,
sizeof(
char));
1516 case FreeRDP_ServerRandom:
1517 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerRandomLength, data,
1519 case FreeRDP_ClientRandom:
1520 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ClientRandomLength, data,
1522 case FreeRDP_ServerCertificate:
1523 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerCertificateLength,
1524 data, len,
sizeof(
char));
1525 case FreeRDP_TargetNetAddresses:
1526 if (!freerdp_target_net_addresses_resize(settings, len))
1529 target_net_addresses_free(settings, 0);
1531 case FreeRDP_ServerLicenseProductIssuers:
1533 freerdp_server_license_issuers_free(settings);
1534 return freerdp_settings_set_pointer_len_(
1535 settings,
id, FreeRDP_ServerLicenseProductIssuersCount, data, len,
sizeof(
char*));
1536 case FreeRDP_TargetNetPorts:
1537 if (!freerdp_target_net_addresses_resize(settings, len))
1541 for (
size_t x = 0; x < len; x++)
1542 settings->TargetNetPorts[x] = 0;
1545 case FreeRDP_DeviceArray:
1547 freerdp_device_collection_free(settings);
1548 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DeviceArraySize, data,
1550 case FreeRDP_ChannelDefArray:
1551 if ((len > 0) && (len < CHANNEL_MAX_COUNT))
1553 "FreeRDP_ChannelDefArray::len expected to be >= %" PRIu32
1554 ", but have %" PRIu32,
1555 CHANNEL_MAX_COUNT, len);
1556 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ChannelDefArray,
1557 FreeRDP_ChannelDefArraySize, data, len,
1559 case FreeRDP_MonitorDefArray:
1560 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_MonitorDefArraySize,
1562 case FreeRDP_ClientAutoReconnectCookie:
1563 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1565 case FreeRDP_ServerAutoReconnectCookie:
1566 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1568 case FreeRDP_ClientTimeZone:
1571 WLog_ERR(TAG,
"FreeRDP_ClientTimeZone::len must be 0 or 1");
1574 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1576 case FreeRDP_BitmapCacheV2CellInfo:
1577 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_BitmapCacheV2NumCells,
1579 case FreeRDP_GlyphCache:
1580 if ((len != 0) && (len != 10))
1582 WLog_ERR(TAG,
"FreeRDP_GlyphCache::len must be 0 or 10");
1585 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1587 case FreeRDP_FragCache:
1590 WLog_ERR(TAG,
"FreeRDP_FragCache::len must be 0 or 1");
1593 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1595 case FreeRDP_StaticChannelArray:
1597 freerdp_static_channel_collection_free(settings);
1598 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_StaticChannelArraySize,
1600 case FreeRDP_DynamicChannelArray:
1602 freerdp_dynamic_channel_collection_free(settings);
1603 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DynamicChannelArraySize,
1605 case FreeRDP_ReceivedCapabilityData:
1606 if (!freerdp_capability_buffer_resize(settings, len, FALSE))
1610 freerdp_capability_data_free(settings, 0, FALSE);
1613 case FreeRDP_ReceivedCapabilities:
1614 if (!freerdp_capability_buffer_resize(settings, len, FALSE))
1618 for (
size_t x = 0; x < settings->ReceivedCapabilitiesSize; x++)
1620 settings->ReceivedCapabilities[x] = 0;
1624 case FreeRDP_OrderSupport:
1625 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1628 case FreeRDP_MonitorIds:
1629 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_NumMonitorIds, data, len,
1632 case FreeRDP_ReceivedCapabilityDataSizes:
1633 if (!freerdp_capability_buffer_resize(settings, len, FALSE))
1637 for (
size_t x = 0; x < settings->ReceivedCapabilitiesSize; x++)
1638 settings->ReceivedCapabilityDataSizes[x] = 0;
1642 case FreeRDP_Password51:
1643 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_Password51Length, data,
1646 if ((data == NULL) && (len == 0))
1651 WLog_WARN(TAG,
"Invalid id %" PRIuz,
id);
1656void* freerdp_settings_get_pointer_array_writable(
const rdpSettings* settings,
1657 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
1664 case FreeRDP_ClientAutoReconnectCookie:
1666 if ((offset >= max) || !settings->ClientAutoReconnectCookie)
1668 return &settings->ClientAutoReconnectCookie[offset];
1669 case FreeRDP_ServerAutoReconnectCookie:
1671 if ((offset >= max) || !settings->ServerAutoReconnectCookie)
1673 return &settings->ServerAutoReconnectCookie[offset];
1674 case FreeRDP_ServerCertificate:
1678 return &settings->ServerCertificate[offset];
1679 case FreeRDP_ServerRandom:
1683 return &settings->ServerRandom[offset];
1684 case FreeRDP_ClientRandom:
1688 return &settings->ClientRandom[offset];
1689 case FreeRDP_LoadBalanceInfo:
1693 return &settings->LoadBalanceInfo[offset];
1695 case FreeRDP_RedirectionTsvUrl:
1699 return &settings->RedirectionTsvUrl[offset];
1701 case FreeRDP_RedirectionPassword:
1705 return &settings->RedirectionPassword[offset];
1707 case FreeRDP_OrderSupport:
1711 return &settings->OrderSupport[offset];
1712 case FreeRDP_MonitorIds:
1716 return &settings->MonitorIds[offset];
1717 case FreeRDP_MonitorDefArray:
1721 return &settings->MonitorDefArray[offset];
1722 case FreeRDP_ChannelDefArray:
1726 return &settings->ChannelDefArray[offset];
1727 case FreeRDP_DeviceArray:
1731 return settings->DeviceArray[offset];
1732 case FreeRDP_StaticChannelArray:
1736 return settings->StaticChannelArray[offset];
1737 case FreeRDP_DynamicChannelArray:
1741 return settings->DynamicChannelArray[offset];
1742 case FreeRDP_FragCache:
1746 return &settings->FragCache[offset];
1747 case FreeRDP_GlyphCache:
1751 return &settings->GlyphCache[offset];
1752 case FreeRDP_BitmapCacheV2CellInfo:
1756 return &settings->BitmapCacheV2CellInfo[offset];
1757 case FreeRDP_ReceivedCapabilities:
1761 return &settings->ReceivedCapabilities[offset];
1762 case FreeRDP_TargetNetAddresses:
1766 WINPR_ASSERT(settings->TargetNetAddresses);
1767 return settings->TargetNetAddresses[offset];
1768 case FreeRDP_TargetNetPorts:
1772 WINPR_ASSERT(settings->TargetNetPorts);
1773 return &settings->TargetNetPorts[offset];
1774 case FreeRDP_ClientTimeZone:
1778 return settings->ClientTimeZone;
1779 case FreeRDP_RdpServerCertificate:
1783 return settings->RdpServerCertificate;
1784 case FreeRDP_RdpServerRsaKey:
1788 return settings->RdpServerRsaKey;
1789 case FreeRDP_ServerLicenseProductIssuers:
1793 return settings->ServerLicenseProductIssuers[offset];
1794 case FreeRDP_ReceivedCapabilityData:
1798 WINPR_ASSERT(settings->ReceivedCapabilityData);
1799 return settings->ReceivedCapabilityData[offset];
1801 case FreeRDP_ReceivedCapabilityDataSizes:
1805 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
1806 return &settings->ReceivedCapabilityDataSizes[offset];
1813 WLog_WARN(TAG,
"Invalid offset for %s [%" PRIuz
"]: size=%" PRIuz
", offset=%" PRIuz,
1818BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1819 size_t offset,
const void* data)
1821 size_t maxOffset = 0;
1826 case FreeRDP_ClientAutoReconnectCookie:
1828 if ((offset >= maxOffset) || !data || !settings->ClientAutoReconnectCookie)
1832 case FreeRDP_ServerAutoReconnectCookie:
1834 if ((offset >= maxOffset) || !data || !settings->ServerAutoReconnectCookie)
1838 case FreeRDP_ServerCertificate:
1840 if ((offset >= maxOffset) || !data)
1842 settings->ServerCertificate[offset] = *(
const BYTE*)data;
1844 case FreeRDP_DeviceArray:
1846 if (offset >= maxOffset)
1848 freerdp_device_free(settings->DeviceArray[offset]);
1849 settings->DeviceArray[offset] = freerdp_device_clone(data);
1851 case FreeRDP_TargetNetAddresses:
1853 if ((offset >= maxOffset) || !data)
1855 WINPR_ASSERT(settings->TargetNetAddresses);
1856 free(settings->TargetNetAddresses[offset]);
1857 settings->TargetNetAddresses[offset] = _strdup((
const char*)data);
1858 return settings->TargetNetAddresses[offset] != NULL;
1859 case FreeRDP_TargetNetPorts:
1861 if ((offset >= maxOffset) || !data)
1863 WINPR_ASSERT(settings->TargetNetPorts);
1864 settings->TargetNetPorts[offset] = *((
const UINT32*)data);
1866 case FreeRDP_StaticChannelArray:
1868 if ((offset >= maxOffset) || !data)
1870 freerdp_addin_argv_free(settings->StaticChannelArray[offset]);
1871 settings->StaticChannelArray[offset] = freerdp_addin_argv_clone(data);
1873 case FreeRDP_DynamicChannelArray:
1875 if ((offset >= maxOffset) || !data)
1877 freerdp_addin_argv_free(settings->DynamicChannelArray[offset]);
1878 settings->DynamicChannelArray[offset] = freerdp_addin_argv_clone(data);
1880 case FreeRDP_BitmapCacheV2CellInfo:
1882 if ((offset >= maxOffset) || !data)
1886 settings->BitmapCacheV2CellInfo[offset] = *cdata;
1889 case FreeRDP_ServerRandom:
1891 if ((offset >= maxOffset) || !data)
1893 settings->ServerRandom[offset] = *(
const BYTE*)data;
1895 case FreeRDP_ClientRandom:
1897 if ((offset >= maxOffset) || !data)
1899 settings->ClientRandom[offset] = *(
const BYTE*)data;
1901 case FreeRDP_LoadBalanceInfo:
1903 if ((offset >= maxOffset) || !data)
1905 settings->LoadBalanceInfo[offset] = *(
const BYTE*)data;
1907 case FreeRDP_RedirectionTsvUrl:
1909 if ((offset >= maxOffset) || !data)
1911 settings->RedirectionTsvUrl[offset] = *(
const BYTE*)data;
1913 case FreeRDP_RedirectionPassword:
1915 if ((offset >= maxOffset) || !data)
1917 settings->RedirectionPassword[offset] = *(
const BYTE*)data;
1919 case FreeRDP_OrderSupport:
1921 if (!settings->OrderSupport)
1923 if ((offset >= maxOffset) || !data)
1925 settings->OrderSupport[offset] = *(
const BOOL*)data ? 1 : 0;
1927 case FreeRDP_GlyphCache:
1929 if (!settings->GlyphCache)
1931 if ((offset >= maxOffset) || !data)
1935 case FreeRDP_FragCache:
1937 if (!settings->FragCache)
1939 if ((offset >= maxOffset) || !data)
1943 case FreeRDP_MonitorIds:
1945 if ((offset >= maxOffset) || !data)
1947 settings->MonitorIds[offset] = *(
const UINT32*)data;
1949 case FreeRDP_ChannelDefArray:
1951 if ((offset >= maxOffset) || !data)
1953 settings->ChannelDefArray[offset] = *(
const CHANNEL_DEF*)data;
1955 case FreeRDP_MonitorDefArray:
1957 if ((offset >= maxOffset) || !data)
1959 settings->MonitorDefArray[offset] = *(
const rdpMonitor*)data;
1962 case FreeRDP_ClientTimeZone:
1964 if ((offset >= maxOffset) || !data || !settings->ClientTimeZone)
1969 case FreeRDP_ServerLicenseProductIssuers:
1972 if ((offset >= maxOffset) || !settings->ServerLicenseProductIssuers)
1974 free(settings->ServerLicenseProductIssuers[offset]);
1975 settings->ServerLicenseProductIssuers[offset] = NULL;
1977 settings->ServerLicenseProductIssuers[offset] = _strdup((
const char*)data);
1980 case FreeRDP_ReceivedCapabilityData:
1982 if (offset >= maxOffset)
1984 WINPR_ASSERT(settings->ReceivedCapabilityData);
1985 settings->ReceivedCapabilityData[offset] = WINPR_CAST_CONST_PTR_AWAY(data, BYTE*);
1987 case FreeRDP_ReceivedCapabilityDataSizes:
1989 if (offset >= maxOffset)
1991 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
1992 settings->ReceivedCapabilityDataSizes[offset] = *(
const uint32_t*)data;
2000 WLog_WARN(TAG,
"[%s] Invalid offset=%" PRIuz
" [%" PRIuz
"] or NULL data=%p",
2005const void* freerdp_settings_get_pointer_array(
const rdpSettings* settings,
2006 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
2008 return freerdp_settings_get_pointer_array_writable(settings,
id, offset);
2013 UINT32 flags = FREERDP_CODEC_ALL;
2014 if (settings->RemoteFxCodec == FALSE)
2016 flags &= (uint32_t)~FREERDP_CODEC_REMOTEFX;
2018 if (settings->NSCodec == FALSE)
2020 flags &= (uint32_t)~FREERDP_CODEC_NSCODEC;
2028 WINPR_ASSERT(settings);
2029 const char* hostname = settings->ServerHostname;
2031 if (settings->UserSpecifiedServerName)
2032 hostname = settings->UserSpecifiedServerName;
2037#if defined(WITH_FREERDP_DEPRECATED)
2040 return freerdp_addin_argv_clone(channel);
2045 return freerdp_addin_argv_clone(channel);
2049BOOL freerdp_target_net_addresses_copy(rdpSettings* settings,
char** addresses, UINT32 count)
2051 WINPR_ASSERT(settings);
2052 WINPR_ASSERT(addresses);
2054 if (!freerdp_target_net_adresses_reset(settings, count))
2057 for (UINT32 i = 0; i < settings->TargetNetAddressCount; i++)
2059 const char* address = addresses[i];
2060 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i, address))
2062 freerdp_target_net_addresses_free(settings);
2072 if (!what && !expect)
2074 if (!what || !expect)
2077 if (what->Id != expect->Id)
2079 if (what->Type != expect->Type)
2081 if (what->Name && expect->Name)
2083 if (strcmp(what->Name, expect->Name) != 0)
2088 if (what->Name != expect->Name)
2094 case RDPDR_DTYP_PRINT:
2098 if (a->DriverName && b->DriverName)
2099 return strcmp(a->DriverName, b->DriverName) == 0;
2100 return a->DriverName == b->DriverName;
2103 case RDPDR_DTYP_SERIAL:
2108 if (a->Path && b->Path)
2110 if (strcmp(a->Path, b->Path) != 0)
2113 else if (a->Path != b->Path)
2116 if (a->Driver && b->Driver)
2118 if (strcmp(a->Driver, b->Driver) != 0)
2121 else if (a->Driver != b->Driver)
2123 if (a->Permissive && b->Permissive)
2124 return strcmp(a->Permissive, b->Permissive) == 0;
2125 return a->Permissive == b->Permissive;
2128 case RDPDR_DTYP_PARALLEL:
2132 if (a->Path && b->Path)
2133 return strcmp(a->Path, b->Path) == 0;
2134 return a->Path == b->Path;
2137 case RDPDR_DTYP_SMARTCARD:
2139 case RDPDR_DTYP_FILESYSTEM:
2143 if (a->automount != b->automount)
2145 if (a->Path && b->Path)
2146 return strcmp(a->Path, b->Path) == 0;
2147 return a->Path == b->Path;
2160 RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
2161 RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
2162 RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED |
2163 RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED;
2165 if (flags & RAIL_LEVEL_SUPPORTED)
2166 winpr_str_append(
"RAIL_LEVEL_SUPPORTED", buffer, length,
"|");
2167 if (flags & RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED)
2168 winpr_str_append(
"RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED", buffer, length,
"|");
2169 if (flags & RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED)
2170 winpr_str_append(
"RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED", buffer, length,
"|");
2171 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2172 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
2173 if (flags & RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED)
2174 winpr_str_append(
"RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED", buffer, length,
"|");
2175 if (flags & RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED)
2176 winpr_str_append(
"RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED", buffer, length,
"|");
2177 if (flags & RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED)
2178 winpr_str_append(
"RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED", buffer, length,
"|");
2179 if (flags & RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED)
2180 winpr_str_append(
"RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED", buffer, length,
"|");
2181 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2182 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
2183 if ((flags & ~mask) != 0)
2185 char tbuffer[64] = { 0 };
2186 (void)_snprintf(tbuffer,
sizeof(tbuffer),
"RAIL_FLAG_UNKNOWN 0x%08" PRIx32, flags & mask);
2187 winpr_str_append(tbuffer, buffer, length,
"|");
2193 const BYTE** capsData,
const UINT32* capsSizes,
2194 UINT32 capsCount, BOOL serverReceivedCaps)
2196 WINPR_ASSERT(settings);
2197 WINPR_ASSERT(capsFlags || (capsCount == 0));
2198 WINPR_ASSERT(capsData || (capsCount == 0));
2199 WINPR_ASSERT(capsSizes || (capsCount == 0));
2200 WINPR_ASSERT(capsCount <= UINT16_MAX);
2202 wLog* log = WLog_Get(TAG);
2204 for (UINT32 x = 0; x < capsCount; x++)
2209 wStream* sub = Stream_StaticConstInit(&buffer, capsData[x], capsSizes[x]);
2211 if (!rdp_read_capability_set(log, sub, (UINT16)x, settings, serverReceivedCaps))
2224 return "RDP_VERSION_4";
2225 case RDP_VERSION_5_PLUS:
2226 return "RDP_VERSION_5_PLUS";
2227 case RDP_VERSION_10_0:
2228 return "RDP_VERSION_10_0";
2229 case RDP_VERSION_10_1:
2230 return "RDP_VERSION_10_1";
2231 case RDP_VERSION_10_2:
2232 return "RDP_VERSION_10_2";
2233 case RDP_VERSION_10_3:
2234 return "RDP_VERSION_10_3";
2235 case RDP_VERSION_10_4:
2236 return "RDP_VERSION_10_4";
2237 case RDP_VERSION_10_5:
2238 return "RDP_VERSION_10_5";
2239 case RDP_VERSION_10_6:
2240 return "RDP_VERSION_10_6";
2241 case RDP_VERSION_10_7:
2242 return "RDP_VERSION_10_7";
2243 case RDP_VERSION_10_8:
2244 return "RDP_VERSION_10_8";
2245 case RDP_VERSION_10_9:
2246 return "RDP_VERSION_10_9";
2247 case RDP_VERSION_10_10:
2248 return "RDP_VERSION_10_10";
2249 case RDP_VERSION_10_11:
2250 return "RDP_VERSION_10_11";
2251 case RDP_VERSION_10_12:
2252 return "RDP_VERSION_10_12";
2254 return "RDP_VERSION_UNKNOWN";
2261 WINPR_ASSERT(settings);
2264 return freerdp_settings_set_string_copy_(settings,
id, NULL, 0, TRUE);
2268 char* str = ConvertWCharToUtf8Alloc(param, &len);
2269 if (!str && (len != 0))
2272 return freerdp_settings_set_string_(settings,
id, str, len);
2276 const WCHAR* param,
size_t length)
2280 WINPR_ASSERT(settings);
2283 return freerdp_settings_set_string_copy_(settings,
id, NULL, length, TRUE);
2285 char* str = ConvertWCharNToUtf8Alloc(param, length, &len);
2286 if (!str && (length != 0))
2290 const size_t wlen = _wcsnlen(param, length);
2295 return freerdp_settings_set_string_(settings,
id, str, len);
2299 FreeRDP_Settings_Keys_String
id,
size_t* pCharLen)
2306 return ConvertUtf8ToWCharAlloc(str, pCharLen);
2313 case RDPDR_DTYP_FILESYSTEM:
2314 return "RDPDR_DTYP_FILESYSTEM";
2315 case RDPDR_DTYP_PARALLEL:
2316 return "RDPDR_DTYP_PARALLEL";
2317 case RDPDR_DTYP_PRINT:
2318 return "RDPDR_DTYP_PRINT";
2319 case RDPDR_DTYP_SERIAL:
2320 return "RDPDR_DTYP_SERIAL";
2321 case RDPDR_DTYP_SMARTCARD:
2322 return "RDPDR_DTYP_SMARTCARD";
2324 return "RDPDR_DTYP_UNKNOWN";
2328const char* freerdp_encryption_level_string(UINT32 EncryptionLevel)
2330 switch (EncryptionLevel)
2332 case ENCRYPTION_LEVEL_NONE:
2333 return "ENCRYPTION_LEVEL_NONE";
2334 case ENCRYPTION_LEVEL_LOW:
2335 return "ENCRYPTION_LEVEL_LOW";
2336 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
2337 return "ENCRYPTION_LEVEL_CLIENT_COMPATIBLE";
2338 case ENCRYPTION_LEVEL_HIGH:
2339 return "ENCRYPTION_LEVEL_HIGH";
2340 case ENCRYPTION_LEVEL_FIPS:
2341 return "ENCRYPTION_LEVEL_FIPS";
2343 return "ENCRYPTION_LEVEL_UNKNOWN";
2347const char* freerdp_encryption_methods_string(UINT32 EncryptionMethods,
char* buffer,
size_t size)
2349 if (EncryptionMethods == ENCRYPTION_METHOD_NONE)
2351 winpr_str_append(
"ENCRYPTION_METHOD_NONE", buffer, size,
"|");
2355 if (EncryptionMethods & ENCRYPTION_METHOD_40BIT)
2357 winpr_str_append(
"ENCRYPTION_METHOD_40BIT", buffer, size,
"|");
2359 if (EncryptionMethods & ENCRYPTION_METHOD_128BIT)
2361 winpr_str_append(
"ENCRYPTION_METHOD_128BIT", buffer, size,
"|");
2363 if (EncryptionMethods & ENCRYPTION_METHOD_56BIT)
2365 winpr_str_append(
"ENCRYPTION_METHOD_56BIT", buffer, size,
"|");
2367 if (EncryptionMethods & ENCRYPTION_METHOD_FIPS)
2369 winpr_str_append(
"ENCRYPTION_METHOD_FIPS", buffer, size,
"|");
2377 const UINT32 invalid = mask & ~(RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
2378 RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT);
2380 if (mask & RNS_UD_32BPP_SUPPORT)
2381 winpr_str_append(
"RNS_UD_32BPP_SUPPORT", buffer, size,
"|");
2382 if (mask & RNS_UD_24BPP_SUPPORT)
2383 winpr_str_append(
"RNS_UD_24BPP_SUPPORT", buffer, size,
"|");
2384 if (mask & RNS_UD_16BPP_SUPPORT)
2385 winpr_str_append(
"RNS_UD_16BPP_SUPPORT", buffer, size,
"|");
2386 if (mask & RNS_UD_15BPP_SUPPORT)
2387 winpr_str_append(
"RNS_UD_15BPP_SUPPORT", buffer, size,
"|");
2391 char str[32] = { 0 };
2392 (void)_snprintf(str,
sizeof(str),
"RNS_UD_INVALID[0x%04" PRIx32
"]", invalid);
2393 winpr_str_append(str, buffer, size,
"|");
2395 char hex[32] = { 0 };
2396 (void)_snprintf(hex,
sizeof(hex),
"[0x%04" PRIx16
"]", mask);
2401 const char* separator,
const char* param)
2409 winpr_asprintf(&str, &len,
"%s", param);
2410 else if (!separator)
2411 winpr_asprintf(&str, &len,
"%s%s", old, param);
2413 winpr_asprintf(&str, &len,
"%s%s%s", old, separator, param);
2422 return settings != NULL;
2429static int sort_monitor_fn(
const void* pva,
const void* pvb)
2435 if (a->is_primary && b->is_primary)
2452 WINPR_ASSERT(monitors || (count == 0));
2466 for (
size_t x = 0; x < count; x++)
2469 if (cur->is_primary)
2477 for (
size_t x = 0; x < count; x++)
2480 if ((cur->x == 0) && (cur->y == 0))
2490 WLog_ERR(TAG,
"Could not find primary monitor, aborting");
2497 WINPR_ASSERT(sorted);
2502 sorted[sortpos] = *primary;
2503 sorted[sortpos].x = 0;
2504 sorted[sortpos].y = 0;
2505 sorted[sortpos].is_primary = TRUE;
2509 const INT32 offsetX = primary->x;
2510 const INT32 offsetY = primary->y;
2516 for (
size_t x = 0; x < count; x++)
2525 sorted[sortpos++] = m;
2529 qsort(sorted, count,
sizeof(
rdpMonitor), sort_monitor_fn);
2532 WINPR_ASSERTING_INT_CAST(uint32_t, count));
2535static BOOL fill_array(WINPR_JSON* array,
const void* data,
size_t length)
2537 const BYTE* pdata = data;
2538 for (
size_t x = 0; x < length; x++)
2540 BYTE val = pdata[x];
2547static BOOL fill_uint32_array(WINPR_JSON* array,
const uint32_t* data,
size_t length)
2549 for (
size_t x = 0; x < length; x++)
2551 uint32_t val = data[x];
2558static WINPR_JSON* json_from_addin_item(
const ADDIN_ARGV* val)
2572 for (
int x = 0; x < val->argc; x++)
2574 const char* str = val->argv[x];
2576 WINPR_JSON* item = NULL;
2597static BOOL json_from_addin_item_array(WINPR_JSON* json,
const rdpSettings* settings,
2598 FreeRDP_Settings_Keys_Pointer key,
size_t count)
2603 for (uint32_t x = 0; x < count; x++)
2605 const ADDIN_ARGV* cval = freerdp_settings_get_pointer_array(settings, key, x);
2612static BOOL add_string_or_null(WINPR_JSON* json,
const char* key,
const char* value)
2621static WINPR_JSON* json_from_device_item(
const RDPDR_DEVICE* val)
2646 if (!add_string_or_null(obj,
"Name", val->Name))
2650 case RDPDR_DTYP_SERIAL:
2651 if (!add_string_or_null(obj,
"Path", device.serial->Path))
2653 if (!add_string_or_null(obj,
"Driver", device.serial->Driver))
2655 if (!add_string_or_null(obj,
"Permissive", device.serial->Permissive))
2658 case RDPDR_DTYP_PARALLEL:
2659 if (!add_string_or_null(obj,
"Path", device.parallel->Path))
2662 case RDPDR_DTYP_PRINT:
2663 if (!add_string_or_null(obj,
"DriverName", device.printer->DriverName))
2668 case RDPDR_DTYP_FILESYSTEM:
2669 if (!add_string_or_null(obj,
"Path", device.drive->Path))
2674 case RDPDR_DTYP_SMARTCARD:
2686static BOOL json_from_device_item_array(WINPR_JSON* json,
const rdpSettings* settings,
2687 FreeRDP_Settings_Keys_Pointer key,
size_t count)
2692 for (uint32_t x = 0; x < count; x++)
2694 const RDPDR_DEVICE* cval = freerdp_settings_get_pointer_array(settings, key, x);
2701static BOOL string_array_to_json(WINPR_JSON* json,
const rdpSettings* settings, uint32_t argc,
2702 FreeRDP_Settings_Keys_Pointer key)
2704 for (uint32_t x = 0; x < argc; x++)
2706 const char* cval = freerdp_settings_get_pointer_array(settings, key, x);
2708 WINPR_JSON* item = NULL;
2719static BOOL wchar_to_json(WINPR_JSON* obj,
const char* key,
const WCHAR* wstr,
size_t len)
2724 const size_t slen = len * 6;
2725 char* str = calloc(1, slen);
2729 WINPR_JSON* jstr = NULL;
2730 SSIZE_T rc = ConvertWCharNToUtf8(wstr, len, str, slen);
2734 return jstr != NULL;
2737static BOOL wchar_from_json(WCHAR* wstr,
size_t len,
const WINPR_JSON* obj,
const char* key)
2748 memset(wstr, 0,
sizeof(WCHAR) * len);
2752 SSIZE_T rc = ConvertUtf8ToWChar(str, wstr, len);
2756static int64_t int_from_json_item(
const WINPR_JSON* item, int64_t min, int64_t max)
2765 if (isinf(val) || isnan(val))
2771 const int64_t ival = (int64_t)val;
2772 if ((ival < min) || (ival > max))
2781static int64_t int_from_json(
const WINPR_JSON* obj,
const char* key, int64_t min, int64_t max)
2789 return int_from_json_item(item, min, max);
2792static uint64_t uint_from_json_item(
const WINPR_JSON* item, uint64_t max)
2801 if (isinf(val) || isnan(val) || (val < 0.0))
2807 const uint64_t uval = (uint64_t)val;
2816static uint64_t uint_from_json(
const WINPR_JSON* obj,
const char* key, uint64_t max)
2825 return uint_from_json_item(item, max);
2828static WINPR_JSON* systemtime_to_json(WINPR_JSON* parent,
const char* key,
const SYSTEMTIME* st)
2859static BOOL systemtime_from_json(
const WINPR_JSON* pobj,
const char* key,
SYSTEMTIME* st)
2871 st->wYear = (uint16_t)uint_from_json(obj,
"wYear", UINT16_MAX);
2872 st->wMonth = (uint16_t)uint_from_json(obj,
"wMonth", UINT16_MAX);
2873 st->wDayOfWeek = (uint16_t)uint_from_json(obj,
"wDayOfWeek", UINT16_MAX);
2874 st->wDay = (uint16_t)uint_from_json(obj,
"wDay", UINT16_MAX);
2875 st->wHour = (uint16_t)uint_from_json(obj,
"wHour", UINT16_MAX);
2876 st->wMinute = (uint16_t)uint_from_json(obj,
"wMinute", UINT16_MAX);
2877 st->wSecond = (uint16_t)uint_from_json(obj,
"wSecond", UINT16_MAX);
2878 st->wMilliseconds = (uint16_t)uint_from_json(obj,
"wMilliseconds", UINT16_MAX);
2890 tz->Bias = (int32_t)int_from_json(json,
"Bias", INT32_MIN, INT32_MAX);
2891 tz->StandardBias = (int32_t)int_from_json(json,
"StandardBias", INT32_MIN, INT32_MAX);
2892 tz->DaylightBias = (int32_t)int_from_json(json,
"DaylightBias", INT32_MIN, INT32_MAX);
2896 if (!systemtime_from_json(json,
"StandardDate", &tz->StandardDate))
2898 if (!systemtime_from_json(json,
"DaylightDate", &tz->DaylightDate))
2901 if (!wchar_from_json(tz->StandardName, ARRAYSIZE(tz->StandardName), json,
"StandardName"))
2903 if (!wchar_from_json(tz->DaylightName, ARRAYSIZE(tz->DaylightName), json,
"DaylightName"))
2909static BOOL ts_info_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer key,
2910 const WINPR_JSON* json)
2919 for (
size_t x = 0; x < count; x++)
2923 if (!ts_info_from_json(tz, obj))
2944 if (!wchar_to_json(obj,
"StandardName", tz.StandardName, ARRAYSIZE(tz.StandardName)))
2947 if (!systemtime_to_json(obj,
"StandardDate", &tz.StandardDate))
2953 if (!wchar_to_json(obj,
"DaylightName", tz.DaylightName, ARRAYSIZE(tz.DaylightName)))
2956 if (!systemtime_to_json(obj,
"DaylightDate", &tz.DaylightDate))
2989 for (
size_t x = 0; x < count; x++)
2991 if (!glyph_cache_def_to_json(json, &def[x]))
3006 def->cacheEntries = (uint16_t)uint_from_json(json,
"cacheEntries", UINT16_MAX);
3007 def->cacheMaximumCellSize = (uint16_t)uint_from_json(json,
"cacheMaximumCellSize", UINT16_MAX);
3011static BOOL glyph_cache_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3012 const WINPR_JSON* json)
3021 for (
size_t x = 0; x < count; x++)
3024 freerdp_settings_get_pointer_array_writable(settings,
id, x);
3026 if (!glyph_cache_def_from_json(cache, obj))
3040 info->numEntries = (uint32_t)uint_from_json(json,
"numEntries", UINT32_MAX);
3052static BOOL bitmap_cache_v2_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3053 const WINPR_JSON* json)
3062 for (
size_t x = 0; x < count; x++)
3065 freerdp_settings_get_pointer_array_writable(settings,
id, x);
3067 if (!bitmap_cache_v2_from_json(cache, obj))
3075 WINPR_ASSERT(cookie);
3082 cookie->cbLen = (uint32_t)uint_from_json(json,
"cbLen", UINT32_MAX);
3083 cookie->version = (uint32_t)uint_from_json(json,
"version", UINT32_MAX);
3084 cookie->logonId = (uint32_t)uint_from_json(json,
"logonId", UINT32_MAX);
3093 if (len != ARRAYSIZE(cookie->securityVerifier))
3097 for (
size_t x = 0; x < len; x++)
3100 const uint64_t val = uint_from_json_item(citem, UINT8_MAX);
3101 cookie->securityVerifier[x] = (uint8_t)val;
3106static BOOL client_cookie_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3107 const WINPR_JSON* json)
3116 for (
size_t x = 0; x < count; x++)
3120 if (!client_cookie_from_json(cache, obj))
3128 WINPR_ASSERT(cookie);
3134 cookie->cbLen = (uint32_t)uint_from_json(json,
"cbLen", UINT32_MAX);
3135 cookie->version = (uint32_t)uint_from_json(json,
"version", UINT32_MAX);
3136 cookie->logonId = (uint32_t)uint_from_json(json,
"logonId", UINT32_MAX);
3145 if (len != ARRAYSIZE(cookie->arcRandomBits))
3149 for (
size_t x = 0; x < len; x++)
3152 cookie->arcRandomBits[x] = (uint8_t)uint_from_json_item(citem, UINT8_MAX);
3157static BOOL server_cookie_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3158 const WINPR_JSON* json)
3167 for (
size_t x = 0; x < count; x++)
3171 if (!server_cookie_from_json(cache, obj))
3177static BOOL channel_def_from_json(
CHANNEL_DEF* cookie,
const WINPR_JSON* json)
3179 WINPR_ASSERT(cookie);
3186 cookie->options = (uint32_t)uint_from_json(json,
"options", UINT32_MAX);
3196 memset(cookie->name, 0,
sizeof(cookie->name));
3199 strncpy(cookie->name, str, strnlen(str, ARRAYSIZE(cookie->name)));
3204static BOOL channel_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3205 const WINPR_JSON* json)
3214 for (
size_t x = 0; x < count; x++)
3216 CHANNEL_DEF* cache = freerdp_settings_get_pointer_array_writable(settings,
id, x);
3218 if (!channel_def_from_json(cache, obj))
3224static BOOL monitor_attributes_from_json(
MONITOR_ATTRIBUTES* attributes,
const WINPR_JSON* json)
3226 WINPR_ASSERT(attributes);
3235 attributes->physicalWidth = (uint32_t)uint_from_json(obj,
"physicalWidth", UINT32_MAX);
3236 attributes->physicalHeight = (uint32_t)uint_from_json(obj,
"physicalHeight", UINT32_MAX);
3237 attributes->orientation = (uint32_t)uint_from_json(obj,
"orientation", UINT32_MAX);
3238 attributes->desktopScaleFactor =
3239 (uint32_t)uint_from_json(obj,
"desktopScaleFactor", UINT32_MAX);
3240 attributes->deviceScaleFactor = (uint32_t)uint_from_json(obj,
"deviceScaleFactor", UINT32_MAX);
3244static BOOL monitor_def_from_json(
rdpMonitor* monitor,
const WINPR_JSON* json)
3246 WINPR_ASSERT(monitor);
3252 monitor->x = (int32_t)int_from_json(json,
"x", INT32_MIN, INT32_MAX);
3253 monitor->y = (int32_t)int_from_json(json,
"y", INT32_MIN, INT32_MAX);
3254 monitor->width = (int32_t)int_from_json(json,
"width", 0, INT32_MAX);
3255 monitor->height = (int32_t)int_from_json(json,
"height", 0, INT32_MAX);
3256 monitor->orig_screen = (uint32_t)uint_from_json(json,
"orig_screen", UINT32_MAX);
3267 return monitor_attributes_from_json(&monitor->attributes, json);
3270static BOOL monitor_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
3271 const WINPR_JSON* json)
3280 for (
size_t x = 0; x < count; x++)
3282 rdpMonitor* cache = freerdp_settings_get_pointer_array_writable(settings,
id, x);
3284 if (!monitor_def_from_json(cache, obj))
3308 for (
size_t x = 0; x < ARRAYSIZE(cs->securityVerifier); x++)
3322 for (
size_t x = 0; x < count; x++)
3324 if (!client_cookie_to_json(json, &cs[x]))
3348 for (
size_t x = 0; x < ARRAYSIZE(cs->arcRandomBits); x++)
3362 for (
size_t x = 0; x < count; x++)
3364 if (!server_cookie_to_json(json, &cs[x]))
3388 for (
size_t x = 0; x < count; x++)
3390 if (!bitmap_cache_v2_to_json(json, &info[x]))
3396static BOOL monitor_attributes_to_json(WINPR_JSON* pobj,
const MONITOR_ATTRIBUTES* attributes)
3398 WINPR_ASSERT(attributes);
3415static BOOL monitor_def_to_json(WINPR_JSON* json,
const rdpMonitor* monitor)
3417 WINPR_ASSERT(monitor);
3436 return monitor_attributes_to_json(obj, &monitor->attributes);
3439static BOOL monitor_def_array_to_json(WINPR_JSON* json,
const rdpMonitor* monitors,
size_t count)
3441 for (
size_t x = 0; x < count; x++)
3443 if (!monitor_def_to_json(json, &monitors[x]))
3449static BOOL channel_def_to_json(WINPR_JSON* json,
const CHANNEL_DEF* channel)
3451 WINPR_ASSERT(channel);
3465static BOOL channel_def_array_to_json(WINPR_JSON* json,
const CHANNEL_DEF* channels,
size_t count)
3467 for (
size_t x = 0; x < count; x++)
3469 if (!channel_def_to_json(json, &channels[x]))
3475static BOOL serialize_pointer(
const rdpSettings* settings, WINPR_JSON* json,
3476 FreeRDP_Settings_Keys_Pointer
id)
3492 case FreeRDP_instance:
3501 return fill_array(jval, &ptr.u,
sizeof(ptr.u));
3503 case FreeRDP_ServerRandom:
3506 return fill_array(jval, val, len);
3508 case FreeRDP_ServerCertificate:
3510 const uint32_t len =
3512 return fill_array(jval, val, len);
3514 case FreeRDP_ClientRandom:
3517 return fill_array(jval, val, len);
3519 case FreeRDP_ServerLicenseProductIssuers:
3521 const uint32_t len =
3523 return string_array_to_json(jval, settings, len, FreeRDP_ServerLicenseProductIssuers);
3525 case FreeRDP_RedirectionPassword:
3527 const uint32_t len =
3529 return fill_array(jval, val, len);
3531 case FreeRDP_RedirectionGuid:
3533 const uint32_t len =
3535 return fill_array(jval, val, len);
3537 case FreeRDP_LoadBalanceInfo:
3539 const uint32_t len =
3541 return fill_array(jval, val, len);
3543 case FreeRDP_ClientTimeZone:
3545 return tz_info_to_json(jval, val);
3547 case FreeRDP_RedirectionTsvUrl:
3549 const uint32_t len =
3551 return fill_array(jval, val, len);
3553 case FreeRDP_GlyphCache:
3555 return glyph_cache_def_array_to_json(jval, val, val ? 10 : 0);
3557 case FreeRDP_FragCache:
3559 return glyph_cache_def_array_to_json(jval, val, val ? 1 : 0);
3561 case FreeRDP_BitmapCacheV2CellInfo:
3563 const uint32_t len =
3565 return bitmap_cache_v2_array_to_json(jval, val, len);
3567 case FreeRDP_OrderSupport:
3569 const uint32_t len = 32;
3570 return fill_array(jval, val, len);
3572 case FreeRDP_ClientAutoReconnectCookie:
3574 return client_cookie_array_to_json(jval, val, 1);
3576 case FreeRDP_ServerAutoReconnectCookie:
3578 return server_cookie_array_to_json(jval, val, 1);
3580 case FreeRDP_Password51:
3583 return fill_array(jval, val, len);
3585 case FreeRDP_ReceivedCapabilities:
3587 const uint32_t len =
3589 return fill_array(jval, val, len);
3591 case FreeRDP_MonitorIds:
3594 return fill_uint32_array(jval, val, len);
3596 case FreeRDP_TargetNetPorts:
3598 const uint32_t len =
3600 return fill_uint32_array(jval, val, len);
3602 case FreeRDP_MonitorDefArray:
3605 return monitor_def_array_to_json(jval, val, len);
3607 case FreeRDP_ChannelDefArray:
3610 return channel_def_array_to_json(jval, val, len);
3612 case FreeRDP_ReceivedCapabilityDataSizes:
3614 const uint32_t len =
3616 return fill_uint32_array(jval, val, len);
3618 case FreeRDP_ReceivedCapabilityData:
3620 const uint32_t len =
3622 const UINT32* pclen =
3627 for (uint32_t x = 0; x < len; x++)
3629 const char* cval = freerdp_settings_get_pointer_array(settings,
id, x);
3636 if (!fill_array(item, cval, pclen[x]))
3641 case FreeRDP_TargetNetAddresses:
3643 const uint32_t len =
3645 return string_array_to_json(jval, settings, len,
id);
3647 case FreeRDP_RedirectionTargetCertificate:
3648 case FreeRDP_RdpServerCertificate:
3650 WINPR_JSON* item = NULL;
3652 char* pem = freerdp_certificate_get_pem(val, &len);
3665 case FreeRDP_RdpServerRsaKey:
3667 WINPR_JSON* item = NULL;
3669 char* pem = freerdp_key_get_pem(val, &len, NULL);
3678 case FreeRDP_DeviceArray:
3681 return json_from_device_item_array(jval, settings,
id, len);
3683 case FreeRDP_StaticChannelArray:
3685 const uint32_t len =
3687 return json_from_addin_item_array(jval, settings,
id, len);
3689 case FreeRDP_DynamicChannelArray:
3691 const uint32_t len =
3693 return json_from_addin_item_array(jval, settings,
id, len);
3695 case FreeRDP_POINTER_UNUSED:
3752 for (
int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
3758 FreeRDP_Settings_Keys_Bool b;
3759 FreeRDP_Settings_Keys_Int16 i16;
3760 FreeRDP_Settings_Keys_UInt16 u16;
3761 FreeRDP_Settings_Keys_Int32 i32;
3762 FreeRDP_Settings_Keys_UInt32 u32;
3763 FreeRDP_Settings_Keys_Int64 i64;
3764 FreeRDP_Settings_Keys_UInt64 u64;
3765 FreeRDP_Settings_Keys_String str;
3766 FreeRDP_Settings_Keys_Pointer ptr;
3774 case RDP_SETTINGS_TYPE_BOOL:
3781 case RDP_SETTINGS_TYPE_UINT16:
3788 case RDP_SETTINGS_TYPE_INT16:
3795 case RDP_SETTINGS_TYPE_UINT32:
3802 case RDP_SETTINGS_TYPE_INT32:
3809 case RDP_SETTINGS_TYPE_UINT64:
3816 case RDP_SETTINGS_TYPE_INT64:
3823 case RDP_SETTINGS_TYPE_STRING:
3837 case RDP_SETTINGS_TYPE_POINTER:
3838 if (!serialize_pointer(settings, jpointer, iter.ptr))
3854 *plength = strlen(str);
3861static BOOL val_from_array(rdpSettings* settings,
const WINPR_JSON* json,
3862 FreeRDP_Settings_Keys_Pointer key,
size_t esize)
3873 size_t count = len / esize;
3874 if (count * esize != len)
3885 for (
size_t x = 0; x < len; x++)
3888 data[x] = (uint8_t)uint_from_json_item(val, UINT8_MAX);
3894static BOOL uintptr_from_array(rdpSettings* settings,
const WINPR_JSON* json)
3896 FreeRDP_Settings_Keys_Pointer key = FreeRDP_instance;
3901 if (len >
sizeof(
void*))
3910 uint8_t u[
sizeof(
void*)];
3914 for (
size_t x = 0; x < len; x++)
3917 ptr.u[x] = (uint8_t)uint_from_json_item(val, UINT8_MAX);
3924static BOOL val_from_uint32_array(rdpSettings* settings,
const WINPR_JSON* json,
3925 FreeRDP_Settings_Keys_Pointer key,
3926 FreeRDP_Settings_Keys_UInt32 keyId)
3941 for (
size_t x = 0; x < len; x++)
3943 UINT32* data = freerdp_settings_get_pointer_array_writable(settings, key, x);
3948 data[0] = (uint32_t)uint_from_json_item(val, UINT32_MAX);
3953static BOOL caps_data_entry_from_json(rdpSettings* settings,
size_t offset,
const WINPR_JSON* json)
3961 return freerdp_settings_set_pointer_array(settings, FreeRDP_ReceivedCapabilityData, offset,
3965 uint8_t* data = calloc(size,
sizeof(uint8_t));
3969 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_ReceivedCapabilityData, offset, data))
3976 for (
size_t x = 0; x < size; x++)
3979 data[x] = (uint8_t)uint_from_json_item(item, UINT8_MAX);
3986static BOOL caps_data_array_from_json(rdpSettings* settings,
const WINPR_JSON* json)
3995 for (uint32_t x = 0; x < count; x++)
3998 if (!caps_data_entry_from_json(settings, x, array))
4004static BOOL str_array_from_json(rdpSettings* settings,
const WINPR_JSON* json,
4005 FreeRDP_Settings_Keys_Pointer key)
4016 for (
size_t x = 0; x < len; x++)
4025 if (!freerdp_settings_set_pointer_array(settings, key, x, val))
4031static BOOL addin_argv_from_json(rdpSettings* settings,
const WINPR_JSON* json,
4032 FreeRDP_Settings_Keys_Pointer key)
4044 for (
size_t x = 0; x < len; x++)
4051 if (!jargc || !array)
4056 const int argc = (int)int_from_json_item(jargc, INT32_MIN, INT32_MAX);
4060 if (jlen != (
size_t)argc)
4065 const char** argv = (
const char**)calloc(jlen,
sizeof(
char*));
4068 for (
size_t y = 0; y < jlen; y++)
4079 ADDIN_ARGV* cval = freerdp_addin_argv_new(jlen, argv);
4083 const BOOL rc = freerdp_settings_set_pointer_array(settings, key, x, cval);
4084 freerdp_addin_argv_free(cval);
4092static char* get_string(
const WINPR_JSON* json,
const char* key)
4098 return WINPR_CAST_CONST_PTR_AWAY(str,
char*);
4101static BOOL get_bool(
const WINPR_JSON* json,
const char* key)
4109static BOOL device_from_json_item(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer key,
4110 size_t offset,
const WINPR_JSON* val)
4126 memset(&device, 0,
sizeof(device));
4129 device.base.Id = (uint32_t)uint_from_json(val,
"Id", UINT32_MAX);
4130 device.base.Type = (uint32_t)uint_from_json(val,
"Type", UINT32_MAX);
4133 device.base.Name = get_string(val,
"Name");
4134 if (!device.base.Name)
4137 switch (device.base.Type)
4139 case RDPDR_DTYP_SERIAL:
4140 device.serial.Path = get_string(val,
"Path");
4141 device.serial.Driver = get_string(val,
"Driver");
4142 device.serial.Permissive = get_string(val,
"Permissive");
4144 case RDPDR_DTYP_PARALLEL:
4145 device.parallel.Path = get_string(val,
"Path");
4147 case RDPDR_DTYP_PRINT:
4148 device.printer.DriverName = get_string(val,
"DriverName");
4149 device.printer.IsDefault = get_bool(val,
"IsDefault");
4151 case RDPDR_DTYP_FILESYSTEM:
4152 device.drive.Path = get_string(val,
"Path");
4153 device.drive.automount = get_bool(val,
"automount");
4155 case RDPDR_DTYP_SMARTCARD:
4159 return freerdp_settings_set_pointer_array(settings, key, offset, &device);
4162static BOOL device_array_from_json(rdpSettings* settings,
const WINPR_JSON* json,
4163 FreeRDP_Settings_Keys_Pointer key)
4175 for (
size_t x = 0; x < len; x++)
4178 if (!device_from_json_item(settings, key, x, val))
4184static const char* pem_from_json(
const WINPR_JSON* jval,
size_t* plen, BOOL* pvalid)
4188 WINPR_ASSERT(pvalid);
4214static BOOL deserialize_pointer(
const WINPR_JSON* json, rdpSettings* settings,
4215 FreeRDP_Settings_Keys_Pointer
id)
4230 case FreeRDP_instance:
4231 return uintptr_from_array(settings, jval);
4232 case FreeRDP_ServerRandom:
4233 case FreeRDP_ServerCertificate:
4234 case FreeRDP_ClientRandom:
4235 case FreeRDP_RedirectionPassword:
4236 case FreeRDP_RedirectionGuid:
4237 case FreeRDP_LoadBalanceInfo:
4238 case FreeRDP_RedirectionTsvUrl:
4239 case FreeRDP_OrderSupport:
4240 case FreeRDP_Password51:
4241 return val_from_array(settings, jval,
id, 1);
4242 case FreeRDP_ReceivedCapabilities:
4243 return val_from_array(settings, jval,
id, 1);
4244 case FreeRDP_ClientTimeZone:
4245 return ts_info_array_from_json(settings,
id, jval);
4246 case FreeRDP_GlyphCache:
4247 return glyph_cache_def_array_from_json(settings,
id, jval);
4248 case FreeRDP_FragCache:
4249 return glyph_cache_def_array_from_json(settings,
id, jval);
4250 case FreeRDP_BitmapCacheV2CellInfo:
4251 return bitmap_cache_v2_array_from_json(settings,
id, jval);
4252 case FreeRDP_ClientAutoReconnectCookie:
4253 return client_cookie_array_from_json(settings,
id, jval);
4254 case FreeRDP_ServerAutoReconnectCookie:
4255 return server_cookie_array_from_json(settings,
id, jval);
4256 case FreeRDP_MonitorDefArray:
4257 return monitor_def_array_from_json(settings,
id, jval);
4258 case FreeRDP_ChannelDefArray:
4259 return channel_def_array_from_json(settings,
id, jval);
4260 case FreeRDP_MonitorIds:
4261 return val_from_uint32_array(settings, jval,
id, FreeRDP_NumMonitorIds);
4262 case FreeRDP_TargetNetPorts:
4263 return val_from_uint32_array(settings, jval,
id, FreeRDP_TargetNetAddressCount);
4264 case FreeRDP_ServerLicenseProductIssuers:
4265 case FreeRDP_TargetNetAddresses:
4266 return str_array_from_json(settings, jval,
id);
4267 case FreeRDP_ReceivedCapabilityDataSizes:
4268 return val_from_uint32_array(settings, jval,
id, FreeRDP_ReceivedCapabilitiesSize);
4269 case FreeRDP_ReceivedCapabilityData:
4270 return caps_data_array_from_json(settings, jval);
4271 case FreeRDP_RedirectionTargetCertificate:
4272 case FreeRDP_RdpServerCertificate:
4276 const char* pem = pem_from_json(jval, &len, &valid);
4282 rdpCertificate* cert = NULL;
4286 if (strnlen(pem, 2) == 0)
4287 cert = freerdp_certificate_new();
4289 cert = freerdp_certificate_new_from_pem(pem);
4294 case FreeRDP_RdpServerRsaKey:
4298 const char* pem = pem_from_json(jval, &len, &valid);
4306 rdpPrivateKey* key = freerdp_key_new_from_pem_enc(pem, NULL);
4311 case FreeRDP_DeviceArray:
4312 return device_array_from_json(settings, jval,
id);
4313 case FreeRDP_StaticChannelArray:
4314 case FreeRDP_DynamicChannelArray:
4315 return addin_argv_from_json(settings, jval,
id);
4316 case FreeRDP_POINTER_UNUSED:
4368 for (
int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
4374 FreeRDP_Settings_Keys_Bool b;
4375 FreeRDP_Settings_Keys_Int16 i16;
4376 FreeRDP_Settings_Keys_UInt16 u16;
4377 FreeRDP_Settings_Keys_Int32 i32;
4378 FreeRDP_Settings_Keys_UInt32 u32;
4379 FreeRDP_Settings_Keys_Int64 i64;
4380 FreeRDP_Settings_Keys_UInt64 u64;
4381 FreeRDP_Settings_Keys_String str;
4382 FreeRDP_Settings_Keys_Pointer ptr;
4389 case RDP_SETTINGS_TYPE_POINTER:
4390 if (!deserialize_pointer(jpointer, settings, iter.ptr))
4398 for (
int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
4404 FreeRDP_Settings_Keys_Bool b;
4405 FreeRDP_Settings_Keys_Int16 i16;
4406 FreeRDP_Settings_Keys_UInt16 u16;
4407 FreeRDP_Settings_Keys_Int32 i32;
4408 FreeRDP_Settings_Keys_UInt32 u32;
4409 FreeRDP_Settings_Keys_Int64 i64;
4410 FreeRDP_Settings_Keys_UInt64 u64;
4411 FreeRDP_Settings_Keys_String str;
4412 FreeRDP_Settings_Keys_Pointer ptr;
4420 case RDP_SETTINGS_TYPE_BOOL:
4432 case RDP_SETTINGS_TYPE_UINT16:
4435 const uint16_t val = (uint16_t)uint_from_json_item(item, UINT16_MAX);
4442 case RDP_SETTINGS_TYPE_INT16:
4445 const int16_t val = (int16_t)int_from_json_item(item, INT16_MIN, INT16_MAX);
4452 case RDP_SETTINGS_TYPE_UINT32:
4455 const uint32_t val = (uint32_t)uint_from_json_item(item, UINT32_MAX);
4462 case RDP_SETTINGS_TYPE_INT32:
4464 const int64_t val = int_from_json(jint32, name, INT32_MIN, INT32_MAX);
4471 case RDP_SETTINGS_TYPE_UINT64:
4473 const uint64_t val = uint_from_json(juint64, name, UINT64_MAX);
4480 case RDP_SETTINGS_TYPE_INT64:
4483 const int64_t val = int_from_json_item(item, INT64_MIN, INT64_MAX);
4490 case RDP_SETTINGS_TYPE_STRING:
4492 const char* val = NULL;
4506 case RDP_SETTINGS_TYPE_POINTER:
WINPR_API WINPR_JSON * WINPR_JSON_CreateString(const char *string)
WINPR_JSON_CreateString.
WINPR_API BOOL WINPR_JSON_HasObjectItem(const WINPR_JSON *object, const char *string)
Check if JSON has an object matching the name.
WINPR_API WINPR_JSON * WINPR_JSON_AddNumberToObject(WINPR_JSON *object, const char *name, double number)
WINPR_JSON_AddNumberToObject.
WINPR_API BOOL WINPR_JSON_IsNull(const WINPR_JSON *item)
Check if JSON item is Null.
WINPR_API BOOL WINPR_JSON_IsString(const WINPR_JSON *item)
Check if JSON item is of type String.
WINPR_API BOOL WINPR_JSON_AddItemToArray(WINPR_JSON *array, WINPR_JSON *item)
Add an item to an existing array.
WINPR_API WINPR_JSON * WINPR_JSON_AddArrayToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddArrayToObject.
WINPR_API BOOL WINPR_JSON_IsBool(const WINPR_JSON *item)
Check if JSON item is of type BOOL.
WINPR_API double WINPR_JSON_GetNumberValue(const WINPR_JSON *item)
Return the Number value of a JSON item.
WINPR_API WINPR_JSON * WINPR_JSON_CreateObject(void)
WINPR_JSON_CreateObject.
WINPR_API WINPR_JSON * WINPR_JSON_CreateArray(void)
WINPR_JSON_CreateArray.
WINPR_API char * WINPR_JSON_Print(WINPR_JSON *item)
Serialize a JSON instance to string for minimal size without formatting see WINPR_JSON_PrintUnformatt...
WINPR_API BOOL WINPR_JSON_IsNumber(const WINPR_JSON *item)
Check if JSON item is of type Number.
WINPR_API WINPR_JSON * WINPR_JSON_GetArrayItem(const WINPR_JSON *array, size_t index)
Return a pointer to an item in the array.
WINPR_API WINPR_JSON * WINPR_JSON_GetObjectItemCaseSensitive(const WINPR_JSON *object, const char *string)
Same as WINPR_JSON_GetObjectItem but with case sensitive matching.
WINPR_API WINPR_JSON * WINPR_JSON_AddStringToObject(WINPR_JSON *object, const char *name, const char *string)
WINPR_JSON_AddStringToObject.
WINPR_API WINPR_JSON * WINPR_JSON_ParseWithLength(const char *value, size_t buffer_length)
Parse a JSON string.
WINPR_API WINPR_JSON * WINPR_JSON_CreateNumber(double num)
WINPR_JSON_CreateNumber.
WINPR_API BOOL WINPR_JSON_IsObject(const WINPR_JSON *item)
Check if JSON item is of type Object.
WINPR_API WINPR_JSON * WINPR_JSON_AddBoolToObject(WINPR_JSON *object, const char *name, BOOL boolean)
WINPR_JSON_AddBoolToObject.
WINPR_API char * WINPR_JSON_PrintUnformatted(WINPR_JSON *item)
Serialize a JSON instance to string without formatting for human readable formatted output see WINPR_...
WINPR_API WINPR_JSON * WINPR_JSON_CreateNull(void)
WINPR_JSON_CreateNull.
WINPR_API const char * WINPR_JSON_GetStringValue(WINPR_JSON *item)
Return the String value of a JSON item.
WINPR_API WINPR_JSON * WINPR_JSON_AddNullToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddNullToObject.
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
WINPR_API size_t WINPR_JSON_GetArraySize(const WINPR_JSON *array)
Get the number of arrayitems from an array.
WINPR_API BOOL WINPR_JSON_IsArray(const WINPR_JSON *item)
Check if JSON item is of type Array.
WINPR_API WINPR_JSON * WINPR_JSON_AddObjectToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddObjectToObject.
WINPR_API BOOL WINPR_JSON_IsTrue(const WINPR_JSON *item)
Check if JSON item is BOOL value True.
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
const char * freerdp_rail_support_flags_to_string(UINT32 flags, char *buffer, size_t length)
Returns a stringified representation of RAIL support flags.
BOOL freerdp_settings_update_from_caps(rdpSettings *settings, const BYTE *capsFlags, const BYTE **capsData, const UINT32 *capsSizes, UINT32 capsCount, BOOL serverReceivedCaps)
Parse capability data and apply to settings.
FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *param)
Sets a string settings value. The param is copied.
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
const char * freerdp_supported_color_depths_string(UINT16 mask, char *buffer, size_t size)
returns a string representation of RNS_UD_XXBPP_SUPPORT values
FREERDP_API rdpSettings * freerdp_settings_new(DWORD flags)
creates a new setting struct
FREERDP_API INT64 freerdp_settings_get_int64(const rdpSettings *settings, FreeRDP_Settings_Keys_Int64 id)
Returns a INT64 settings value.
BOOL freerdp_settings_set_string_from_utf16N(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const WCHAR *param, size_t length)
Sets a string settings value. The param is converted to UTF-8 and the copy stored.
const char * freerdp_rdp_version_string(UINT32 version)
Returns a stringified representation of the RDP protocol version.
FREERDP_API SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
Get a key type for the key index.
BOOL freerdp_settings_are_valid(const rdpSettings *settings)
Returns TRUE if settings are in a valid state, FALSE otherwise.
FREERDP_API UINT64 freerdp_settings_get_uint64(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt64 id)
Returns a UINT64 settings value.
FREERDP_API SSIZE_T freerdp_settings_get_key_for_name(const char *value)
Get a key index for the name string of that key.
BOOL freerdp_settings_set_pointer_len(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data, size_t len)
Set a pointer to value data.
char * freerdp_settings_serialize(const rdpSettings *settings, BOOL pretty, size_t *plength)
A function that converts a rdpSettings struct to a JSON serialized string.
FREERDP_API BOOL freerdp_settings_set_int32(rdpSettings *settings, FreeRDP_Settings_Keys_Int32 id, INT32 param)
Sets a INT32 settings value.
const char * freerdp_rdpdr_dtyp_string(UINT32 type)
Returns a string representation of RDPDR_DTYP_*.
FREERDP_API void freerdp_settings_free(rdpSettings *settings)
Free a settings struct with all data in it.
BOOL freerdp_settings_set_monitor_def_array_sorted(rdpSettings *settings, const rdpMonitor *monitors, size_t count)
Sort monitor array according to:
FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id)
Returns a UINT16 settings value.
FREERDP_API void * freerdp_settings_get_pointer_writable(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a mutable pointer settings value.
WCHAR * freerdp_settings_get_string_as_utf16(const rdpSettings *settings, FreeRDP_Settings_Keys_String id, size_t *pCharLen)
Return an allocated UTF16 string.
BOOL freerdp_device_collection_del(rdpSettings *settings, const RDPDR_DEVICE *device)
Removed a device from the settings, returns ownership of the allocated device to caller.
BOOL freerdp_set_gateway_usage_method(rdpSettings *settings, UINT32 GatewayUsageMethod)
FREERDP_API BOOL freerdp_settings_set_uint64(rdpSettings *settings, FreeRDP_Settings_Keys_UInt64 id, UINT64 param)
Sets a UINT64 settings value.
FREERDP_API BOOL freerdp_settings_set_int16(rdpSettings *settings, FreeRDP_Settings_Keys_Int16 id, INT16 param)
Sets a INT16 settings value.
FREERDP_API BOOL freerdp_settings_set_int64(rdpSettings *settings, FreeRDP_Settings_Keys_Int64 id, INT64 param)
Sets a INT64 settings value.
BOOL freerdp_settings_set_string_from_utf16(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const WCHAR *param)
Sets a string settings value. The param is converted to UTF-8 and the copy stored.
FREERDP_API BOOL freerdp_settings_set_pointer(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data)
Set a pointer to value data.
FREERDP_API INT32 freerdp_settings_get_int32(const rdpSettings *settings, FreeRDP_Settings_Keys_Int32 id)
Returns a INT32 settings value.
const char * freerdp_settings_get_server_name(const rdpSettings *settings)
A helper function to return the correct server name.
const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
UINT32 freerdp_settings_get_codecs_flags(const rdpSettings *settings)
helper function to get a mask of supported codec flags.
FREERDP_API BOOL freerdp_settings_set_string_len(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *param, size_t len)
Sets a string settings value. The param is copied.
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
BOOL freerdp_settings_append_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *separator, const char *param)
appends a string to a settings value. The param is copied. If the initial value of the setting was no...
FREERDP_API const char * freerdp_settings_get_name_for_key(SSIZE_T key)
Returns the type name for a key.
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
FREERDP_API BOOL freerdp_settings_set_uint16(rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id, UINT16 param)
Sets a UINT16 settings value.
FREERDP_API const char * freerdp_settings_get_type_name_for_type(SSIZE_T type)
Returns the type name for a type.
FREERDP_API INT16 freerdp_settings_get_int16(const rdpSettings *settings, FreeRDP_Settings_Keys_Int16 id)
Returns a INT16 settings value.
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.
rdpSettings * freerdp_settings_deserialize(const char *jstr, size_t length)
A function that converts a JSON string to a rdpSettings struct.