23#include <freerdp/config.h>
31#include <winpr/assert.h>
32#include <winpr/cast.h>
34#include "../core/settings.h"
35#include "../core/capabilities.h"
37#include <freerdp/crypto/certificate.h>
38#include <freerdp/settings.h>
39#include <freerdp/freerdp.h>
40#include <freerdp/log.h>
42#define TAG FREERDP_TAG("common")
44BOOL freerdp_addin_argv_add_argument_ex(
ADDIN_ARGV* args,
const char* argument,
size_t len)
47 char** new_argv = NULL;
49 if (!args || !argument)
53 len = strlen(argument);
55 new_argv = (
char**)realloc(
56 (
void*)args->argv,
sizeof(
char*) * (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc) + 1));
61 args->argv = new_argv;
63 str = calloc(len + 1,
sizeof(
char));
66 memcpy(str, argument, len);
67 args->argv[args->argc++] = str;
71BOOL freerdp_addin_argv_add_argument(
ADDIN_ARGV* args,
const char* argument)
73 return freerdp_addin_argv_add_argument_ex(args, argument, 0);
76BOOL freerdp_addin_argv_del_argument(
ADDIN_ARGV* args,
const char* argument)
78 if (!args || !argument)
80 for (
int x = 0; x < args->argc; x++)
82 char* arg = args->argv[x];
83 if (strcmp(argument, arg) == 0)
86 memmove_s((
void*)&args->argv[x],
87 (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc - x)) *
sizeof(
char*),
88 (
void*)&args->argv[x + 1],
89 (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc - x - 1)) *
sizeof(
char*));
90 args->argv[args->argc - 1] = NULL;
98int freerdp_addin_set_argument(
ADDIN_ARGV* args,
const char* argument)
100 if (!args || !argument)
103 for (
int i = 0; i < args->argc; i++)
105 if (strcmp(args->argv[i], argument) == 0)
111 if (!freerdp_addin_argv_add_argument(args, argument))
116int freerdp_addin_replace_argument(
ADDIN_ARGV* args,
const char* previous,
const char* argument)
118 if (!args || !previous || !argument)
121 for (
int i = 0; i < args->argc; i++)
123 if (strcmp(args->argv[i], previous) == 0)
127 if (!(args->argv[i] = _strdup(argument)))
134 if (!freerdp_addin_argv_add_argument(args, argument))
139int freerdp_addin_set_argument_value(
ADDIN_ARGV* args,
const char* option,
const char* value)
145 if (!args || !option || !value)
147 length = strlen(option) + strlen(value) + 1;
148 str = (
char*)calloc(length + 1,
sizeof(
char));
153 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
155 for (
int i = 0; i < args->argc; i++)
157 p = strchr(args->argv[i],
':');
161 if (strncmp(args->argv[i], option,
162 WINPR_ASSERTING_INT_CAST(
size_t, p - args->argv[i])) == 0)
171 rc = freerdp_addin_argv_add_argument(args, str);
178int freerdp_addin_replace_argument_value(
ADDIN_ARGV* args,
const char* previous,
const char* option,
184 if (!args || !previous || !option || !value)
186 length = strlen(option) + strlen(value) + 1;
187 str = (
char*)calloc(length + 1,
sizeof(
char));
192 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
194 for (
int i = 0; i < args->argc; i++)
196 if (strcmp(args->argv[i], previous) == 0)
204 rc = freerdp_addin_argv_add_argument(args, str);
211BOOL freerdp_device_collection_add(rdpSettings* settings,
RDPDR_DEVICE* device)
215 WINPR_ASSERT(settings);
216 WINPR_ASSERT(device);
222 UINT32 new_size = old * 2;
226 new_size = count * 2;
234 settings->DeviceArray = new_array;
235 memset((
void*)&settings->DeviceArray[old], 0, (new_size - old) *
sizeof(
RDPDR_DEVICE*));
241 settings->DeviceArray[settings->DeviceCount++] = device;
247 WINPR_ASSERT(settings);
252 const UINT32 count = settings->DeviceCount;
253 for (
size_t x = 0; x < count; x++)
258 for (
size_t y = x + 1; y < count; y++)
261 settings->DeviceArray[y - 1] = next;
263 settings->DeviceArray[count - 1] = NULL;
264 settings->DeviceCount--;
272RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings,
const char* name)
276 WINPR_ASSERT(settings);
278 for (UINT32 index = 0; index < settings->DeviceCount; index++)
280 device = settings->DeviceArray[index];
285 if (strcmp(device->Name, name) == 0)
292RDPDR_DEVICE* freerdp_device_collection_find_type(rdpSettings* settings, UINT32 type)
295 WINPR_ASSERT(settings);
297 for (UINT32 index = 0; index < settings->DeviceCount; index++)
299 device = settings->DeviceArray[index];
301 if (device->Type == type)
308RDPDR_DEVICE* freerdp_device_new(UINT32 Type,
size_t count,
const char*
const args[])
322 WINPR_ASSERT(args || (count == 0));
326 case RDPDR_DTYP_PRINT:
329 case RDPDR_DTYP_SERIAL:
332 case RDPDR_DTYP_PARALLEL:
335 case RDPDR_DTYP_SMARTCARD:
338 case RDPDR_DTYP_FILESYSTEM:
345 device.base = calloc(1, size);
349 device.base->Type = Type;
353 device.base->Name = _strdup(args[0]);
354 if (!device.base->Name)
359 case RDPDR_DTYP_PRINT:
362 device.printer->DriverName = _strdup(args[1]);
363 if (!device.printer->DriverName)
369 device.printer->IsDefault = _stricmp(args[2],
"default") == 0;
372 case RDPDR_DTYP_SERIAL:
375 device.serial->Path = _strdup(args[1]);
376 if (!device.serial->Path)
382 device.serial->Driver = _strdup(args[2]);
383 if (!device.serial->Driver)
389 device.serial->Permissive = _strdup(args[3]);
390 if (!device.serial->Permissive)
394 case RDPDR_DTYP_PARALLEL:
397 device.parallel->Path = _strdup(args[1]);
398 if (!device.serial->Path)
402 case RDPDR_DTYP_SMARTCARD:
404 case RDPDR_DTYP_FILESYSTEM:
407 device.drive->Path = _strdup(args[1]);
408 if (!device.drive->Path)
412 device.drive->automount = (args[2] == NULL) ? TRUE : FALSE;
421 freerdp_device_free(device.base);
442 switch (device->Type)
444 case RDPDR_DTYP_PRINT:
445 free(cnv.printer->DriverName);
447 case RDPDR_DTYP_SERIAL:
448 free(cnv.serial->Path);
449 free(cnv.serial->Driver);
450 free(cnv.serial->Permissive);
452 case RDPDR_DTYP_PARALLEL:
453 free(cnv.parallel->Path);
455 case RDPDR_DTYP_SMARTCARD:
457 case RDPDR_DTYP_FILESYSTEM:
458 free(cnv.drive->Path);
489 const char* args[4] = { 0 };
500 args[0] = device->Name;
503 switch (device->Type)
505 case RDPDR_DTYP_FILESYSTEM:
508 args[1] = src.drive->Path;
513 case RDPDR_DTYP_PRINT:
514 if (src.printer->DriverName)
516 args[1] = src.printer->DriverName;
521 case RDPDR_DTYP_SMARTCARD:
524 case RDPDR_DTYP_SERIAL:
525 if (src.serial->Path)
527 args[1] = src.serial->Path;
531 if (src.serial->Driver)
533 args[2] = src.serial->Driver;
537 if (src.serial->Permissive)
539 args[3] = src.serial->Permissive;
544 case RDPDR_DTYP_PARALLEL:
545 if (src.parallel->Path)
547 args[1] = src.parallel->Path;
552 WLog_ERR(TAG,
"unknown device type %" PRIu32
"", device->Type);
556 copy.dev = freerdp_device_new(device->Type, count, args);
560 copy.dev->Id = device->Id;
565void freerdp_device_collection_free(rdpSettings* settings)
567 WINPR_ASSERT(settings);
569 if (settings->DeviceArray)
571 for (UINT32 index = 0; index < settings->DeviceArraySize; index++)
572 (
void)freerdp_settings_set_pointer_array(settings, FreeRDP_DeviceArray, index, NULL);
575 free((
void*)settings->DeviceArray);
582BOOL freerdp_static_channel_collection_del(rdpSettings* settings,
const char* name)
585 if (!settings || !settings->StaticChannelArray)
588 for (UINT32 x = 0; x < count; x++)
590 ADDIN_ARGV* cur = settings->StaticChannelArray[x];
591 if (cur && (cur->argc > 0))
593 if (strcmp(name, cur->argv[0]) == 0)
595 const size_t rem = settings->StaticChannelArraySize - count + 1;
596 memmove_s((
void*)&settings->StaticChannelArray[x],
598 (
void*)&settings->StaticChannelArray[x + 1],
600 memset((
void*)&settings->StaticChannelArray[count - 1], 0,
603 freerdp_addin_argv_free(cur);
609 const size_t rem = settings->StaticChannelArraySize - count;
610 memset((
void*)&settings->StaticChannelArray[count], 0,
sizeof(
ADDIN_ARGV*) * rem);
615BOOL freerdp_static_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
619 WINPR_ASSERT(settings);
620 WINPR_ASSERT(channel);
625 const UINT32 oldSize =
627 UINT32 new_size = oldSize * 2ul;
630 new_size = count * 2ul;
632 new_array = (
ADDIN_ARGV**)realloc((
void*)settings->StaticChannelArray,
638 settings->StaticChannelArray = new_array;
640 const size_t rem = new_size - oldSize;
641 memset((
void*)&settings->StaticChannelArray[oldSize], 0,
sizeof(
ADDIN_ARGV*) * rem);
649 ADDIN_ARGV** cur = &settings->StaticChannelArray[count++];
650 freerdp_addin_argv_free(*cur);
655ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings,
const char* name)
659 WINPR_ASSERT(settings);
662 for (UINT32 index = 0;
665 channel = settings->StaticChannelArray[index];
667 if (strcmp(channel->argv[0], name) == 0)
674void freerdp_static_channel_collection_free(rdpSettings* settings)
679 if (settings->StaticChannelArray)
683 freerdp_addin_argv_free(settings->StaticChannelArray[i]);
686 free((
void*)settings->StaticChannelArray);
688 settings->StaticChannelArray = NULL;
692BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings,
const char* name)
695 if (!settings || !settings->DynamicChannelArray)
698 for (UINT32 x = 0; x < count; x++)
700 ADDIN_ARGV* cur = settings->DynamicChannelArray[x];
701 if (cur && (cur->argc > 0))
703 if (strcmp(name, cur->argv[0]) == 0)
705 const size_t rem = settings->DynamicChannelArraySize - count + 1;
706 memmove_s((
void*)&settings->DynamicChannelArray[x],
708 (
void*)&settings->DynamicChannelArray[x + 1],
710 memset((
void*)&settings->DynamicChannelArray[count - 1], 0,
713 freerdp_addin_argv_free(cur);
723BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
728 WINPR_ASSERT(settings);
729 WINPR_ASSERT(channel);
736 UINT32 size = oldSize * 2;
746 settings->DynamicChannelArray = new_array;
748 const size_t rem = size - oldSize;
749 memset((
void*)&settings->DynamicChannelArray[oldSize], 0,
sizeof(
ADDIN_ARGV*) * rem);
756 settings->DynamicChannelArray[count++] = channel;
760ADDIN_ARGV* freerdp_dynamic_channel_collection_find(
const rdpSettings* settings,
const char* name)
762 WINPR_ASSERT(settings);
765 for (UINT32 index = 0;
768 ADDIN_ARGV* channel = settings->DynamicChannelArray[index];
770 if (strcmp(channel->argv[0], name) == 0)
784 for (
int index = 0; index < args->argc; index++)
785 free(args->argv[index]);
786 free((
void*)args->argv);
792ADDIN_ARGV* freerdp_addin_argv_new(
size_t argc,
const char*
const argv[])
794 if (argc > INT32_MAX)
803 args->argc = (int)argc;
804 args->argv = (
char**)calloc(argc,
sizeof(
char*));
810 for (
size_t x = 0; x < argc; x++)
812 args->argv[x] = _strdup(argv[x]);
820 WINPR_PRAGMA_DIAG_PUSH
821 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
822 freerdp_addin_argv_free(args);
823 WINPR_PRAGMA_DIAG_POP
837 return freerdp_addin_argv_new(WINPR_ASSERTING_INT_CAST(uint32_t, args->argc), cnv.cc);
840void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
842 WINPR_ASSERT(settings);
844 if (settings->DynamicChannelArray)
848 freerdp_addin_argv_free(settings->DynamicChannelArray[i]);
851 free((
void*)settings->DynamicChannelArray);
853 settings->DynamicChannelArray = NULL;
857void freerdp_capability_buffer_free(rdpSettings* settings)
859 WINPR_ASSERT(settings);
861 if (settings->ReceivedCapabilityData)
863 for (UINT32 x = 0; x < settings->ReceivedCapabilitiesSize; x++)
865 free(settings->ReceivedCapabilityData[x]);
866 settings->ReceivedCapabilityData[x] = NULL;
869 settings->ReceivedCapabilitiesSize = 0;
871 free(settings->ReceivedCapabilityDataSizes);
872 settings->ReceivedCapabilityDataSizes = NULL;
874 free((
void*)settings->ReceivedCapabilityData);
875 settings->ReceivedCapabilityData = NULL;
876 free(settings->ReceivedCapabilities);
877 settings->ReceivedCapabilities = NULL;
880BOOL freerdp_capability_buffer_copy(rdpSettings* settings,
const rdpSettings* src)
882 WINPR_ASSERT(settings);
885 if (!freerdp_capability_buffer_allocate(settings, src->ReceivedCapabilitiesSize))
888 for (UINT32 x = 0; x < src->ReceivedCapabilitiesSize; x++)
890 WINPR_ASSERT(settings->ReceivedCapabilities);
891 settings->ReceivedCapabilities[x] = src->ReceivedCapabilities[x];
893 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
894 settings->ReceivedCapabilityDataSizes[x] = src->ReceivedCapabilityDataSizes[x];
896 WINPR_ASSERT(settings->ReceivedCapabilityData);
897 if (src->ReceivedCapabilityDataSizes[x] > 0)
899 void* tmp = realloc(settings->ReceivedCapabilityData[x],
900 settings->ReceivedCapabilityDataSizes[x]);
903 memcpy(tmp, src->ReceivedCapabilityData[x], src->ReceivedCapabilityDataSizes[x]);
904 settings->ReceivedCapabilityData[x] = tmp;
908 free(settings->ReceivedCapabilityData[x]);
909 settings->ReceivedCapabilityData[x] = NULL;
915void freerdp_target_net_addresses_free(rdpSettings* settings)
917 WINPR_ASSERT(settings);
919 if (settings->TargetNetAddresses)
921 for (UINT32 index = 0; index < settings->TargetNetAddressCount; index++)
922 free(settings->TargetNetAddresses[index]);
925 free((
void*)settings->TargetNetAddresses);
926 free(settings->TargetNetPorts);
927 settings->TargetNetAddressCount = 0;
928 settings->TargetNetAddresses = NULL;
929 settings->TargetNetPorts = NULL;
932void freerdp_server_license_issuers_free(rdpSettings* settings)
934 WINPR_ASSERT(settings);
936 if (settings->ServerLicenseProductIssuers)
938 for (UINT32 x = 0; x < settings->ServerLicenseProductIssuersCount; x++)
939 free(settings->ServerLicenseProductIssuers[x]);
941 free((
void*)settings->ServerLicenseProductIssuers);
942 settings->ServerLicenseProductIssuers = NULL;
943 settings->ServerLicenseProductIssuersCount = 0;
946BOOL freerdp_server_license_issuers_copy(rdpSettings* settings,
char** issuers, UINT32 count)
948 WINPR_ASSERT(settings);
949 WINPR_ASSERT(issuers || (count == 0));
955 for (UINT32 x = 0; x < count; x++)
957 char* issuer = _strdup(issuers[x]);
960 settings->ServerLicenseProductIssuers[x] = issuer;
966void freerdp_performance_flags_make(rdpSettings* settings)
968 UINT32 PerformanceFlags = PERF_FLAG_NONE;
971 PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING;
974 PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION;
977 PerformanceFlags |= PERF_DISABLE_WALLPAPER;
980 PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG;
983 PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS;
986 PerformanceFlags |= PERF_DISABLE_THEMING;
990void freerdp_performance_flags_split(rdpSettings* settings)
993 settings, FreeRDP_AllowFontSmoothing,
995 PERF_ENABLE_FONT_SMOOTHING)
999 settings, FreeRDP_AllowDesktopComposition,
1001 PERF_ENABLE_DESKTOP_COMPOSITION)
1005 settings, FreeRDP_DisableWallpaper,
1010 settings, FreeRDP_DisableFullWindowDrag,
1012 PERF_DISABLE_FULLWINDOWDRAG)
1016 settings, FreeRDP_DisableMenuAnims,
1018 PERF_DISABLE_MENUANIMATIONS)
1022 settings, FreeRDP_DisableThemes,
1033 if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT)
1039 else if (GatewayUsageMethod == TSC_PROXY_MODE_DIRECT)
1045 else if (GatewayUsageMethod == TSC_PROXY_MODE_DETECT)
1051 else if (GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT)
1062 else if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT)
1072void freerdp_update_gateway_usage_method(rdpSettings* settings, UINT32 GatewayEnabled,
1073 UINT32 GatewayBypassLocal)
1075 UINT32 GatewayUsageMethod = 0;
1077 if (!GatewayEnabled && !GatewayBypassLocal)
1078 GatewayUsageMethod = TSC_PROXY_MODE_NONE_DIRECT;
1079 else if (GatewayEnabled && !GatewayBypassLocal)
1080 GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
1081 else if (GatewayEnabled && GatewayBypassLocal)
1082 GatewayUsageMethod = TSC_PROXY_MODE_DETECT;
1087#if defined(WITH_FREERDP_DEPRECATED)
1088BOOL freerdp_get_param_bool(
const rdpSettings* settings,
int id)
1093int freerdp_set_param_bool(rdpSettings* settings,
int id, BOOL param)
1098int freerdp_get_param_int(
const rdpSettings* settings,
int id)
1103int freerdp_set_param_int(rdpSettings* settings,
int id,
int param)
1108UINT32 freerdp_get_param_uint32(
const rdpSettings* settings,
int id)
1113int freerdp_set_param_uint32(rdpSettings* settings,
int id, UINT32 param)
1118UINT64 freerdp_get_param_uint64(
const rdpSettings* settings,
int id)
1123int freerdp_set_param_uint64(rdpSettings* settings,
int id, UINT64 param)
1128char* freerdp_get_param_string(
const rdpSettings* settings,
int id)
1131 return WINPR_CAST_CONST_PTR_AWAY(str,
char*);
1134int freerdp_set_param_string(rdpSettings* settings,
int id,
const char* param)
1140static BOOL value_to_uint(
const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
1142 char* endptr = NULL;
1143 unsigned long long rc = 0;
1145 if (!value || !result)
1149 rc = _strtoui64(value, &endptr, 0);
1154 if (endptr == value)
1157 if ((rc < min) || (rc > max))
1164static BOOL value_to_int(
const char* value, LONGLONG* result, LONGLONG min, LONGLONG max)
1166 char* endptr = NULL;
1169 if (!value || !result)
1173 rc = _strtoi64(value, &endptr, 0);
1178 if (endptr == value)
1181 if ((rc < min) || (rc > max))
1188static BOOL parsing_fail(
const char* key,
const char* type,
const char* value)
1190 WLog_ERR(TAG,
"Failed to parse key [%s] of type [%s]: value [%s]", key, type, value);
1194BOOL freerdp_settings_set_value_for_name(rdpSettings* settings,
const char* name,
const char* value)
1200 if (!settings || !name)
1206 WLog_ERR(TAG,
"Invalid settings key [%s]", name);
1210 const SSIZE_T index = i;
1216 case RDP_SETTINGS_TYPE_BOOL:
1218 const BOOL val = (_strnicmp(value,
"TRUE", 5) == 0) || (_strnicmp(value,
"ON", 5) == 0);
1220 (_strnicmp(value,
"FALSE", 6) == 0) || (_strnicmp(value,
"OFF", 6) == 0);
1222 return parsing_fail(name,
"BOOL", value);
1227 case RDP_SETTINGS_TYPE_UINT16:
1228 if (!value_to_uint(value, &uval, 0, UINT16_MAX))
1229 return parsing_fail(name,
"UINT16", value);
1234 return parsing_fail(name,
"UINT16", value);
1237 case RDP_SETTINGS_TYPE_INT16:
1238 if (!value_to_int(value, &ival, INT16_MIN, INT16_MAX))
1239 return parsing_fail(name,
"INT16", value);
1244 return parsing_fail(name,
"INT16", value);
1246 case RDP_SETTINGS_TYPE_UINT32:
1247 if (!value_to_uint(value, &uval, 0, UINT32_MAX))
1248 return parsing_fail(name,
"UINT32", value);
1253 return parsing_fail(name,
"UINT32", value);
1255 case RDP_SETTINGS_TYPE_INT32:
1256 if (!value_to_int(value, &ival, INT32_MIN, INT32_MAX))
1257 return parsing_fail(name,
"INT32", value);
1262 return parsing_fail(name,
"INT32", value);
1264 case RDP_SETTINGS_TYPE_UINT64:
1265 if (!value_to_uint(value, &uval, 0, UINT64_MAX))
1266 return parsing_fail(name,
"UINT64", value);
1270 return parsing_fail(name,
"UINT64", value);
1272 case RDP_SETTINGS_TYPE_INT64:
1273 if (!value_to_int(value, &ival, INT64_MIN, INT64_MAX))
1274 return parsing_fail(name,
"INT64", value);
1278 return parsing_fail(name,
"INT64", value);
1281 case RDP_SETTINGS_TYPE_STRING:
1285 case RDP_SETTINGS_TYPE_POINTER:
1286 return parsing_fail(name,
"POINTER", value);
1293BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1294 FreeRDP_Settings_Keys_UInt32 lenId,
const void* data,
1295 size_t len,
size_t size)
1303 if (lenId != FreeRDP_UINT32_UNUSED)
1309 if (len > UINT32_MAX)
1313 copy = calloc(len, size);
1317 memcpy(copy, data, len * size);
1327 if (lenId == FreeRDP_UINT32_UNUSED)
1333 FreeRDP_Settings_Keys_Pointer
id)
1337 const rdpSettings* pc;
1345 const void* data,
size_t len)
1359 case FreeRDP_RdpServerCertificate:
1360 freerdp_certificate_free(settings->RdpServerCertificate);
1364 WLog_ERR(TAG,
"FreeRDP_RdpServerCertificate::len must be 0 or 1");
1367 settings->RdpServerCertificate = cnv.v;
1368 if (!settings->RdpServerCertificate && (len > 0))
1370 settings->RdpServerCertificate = freerdp_certificate_new();
1371 if (!settings->RdpServerCertificate)
1375 case FreeRDP_RdpServerRsaKey:
1376 freerdp_key_free(settings->RdpServerRsaKey);
1379 WLog_ERR(TAG,
"FreeRDP_RdpServerRsaKey::len must be 0 or 1");
1382 settings->RdpServerRsaKey = (rdpPrivateKey*)cnv.v;
1383 if (!settings->RdpServerRsaKey && (len > 0))
1385 settings->RdpServerRsaKey = freerdp_key_new();
1386 if (!settings->RdpServerRsaKey)
1390 case FreeRDP_RedirectionPassword:
1391 return freerdp_settings_set_pointer_len_(
1392 settings,
id, FreeRDP_RedirectionPasswordLength, data, len,
sizeof(
char));
1393 case FreeRDP_RedirectionTsvUrl:
1394 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionTsvUrlLength,
1395 data, len,
sizeof(
char));
1396 case FreeRDP_RedirectionTargetCertificate:
1397 freerdp_certificate_free(settings->RedirectionTargetCertificate);
1401 WLog_ERR(TAG,
"FreeRDP_RedirectionTargetCertificate::len must be 0 or 1");
1404 settings->RedirectionTargetCertificate = cnv.v;
1405 if (!settings->RedirectionTargetCertificate && (len > 0))
1407 settings->RedirectionTargetCertificate = freerdp_certificate_new();
1408 if (!settings->RedirectionTargetCertificate)
1412 case FreeRDP_RedirectionGuid:
1413 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionGuidLength,
1414 data, len,
sizeof(BYTE));
1415 case FreeRDP_LoadBalanceInfo:
1416 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_LoadBalanceInfoLength,
1417 data, len,
sizeof(
char));
1418 case FreeRDP_ServerRandom:
1419 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerRandomLength, data,
1421 case FreeRDP_ClientRandom:
1422 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ClientRandomLength, data,
1424 case FreeRDP_ServerCertificate:
1425 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerCertificateLength,
1426 data, len,
sizeof(
char));
1427 case FreeRDP_TargetNetAddresses:
1428 if ((data == NULL) && (len == 0))
1430 freerdp_target_net_addresses_free(settings);
1435 "[BUG] FreeRDP_TargetNetAddresses must not be resized from outside the library!");
1437 case FreeRDP_ServerLicenseProductIssuers:
1439 freerdp_server_license_issuers_free(settings);
1440 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ServerLicenseProductIssuers,
1441 FreeRDP_ServerLicenseProductIssuersCount, data,
1442 len,
sizeof(
char*));
1443 case FreeRDP_TargetNetPorts:
1444 if ((data == NULL) && (len == 0))
1446 freerdp_target_net_addresses_free(settings);
1450 "[BUG] FreeRDP_TargetNetPorts must not be resized from outside the library!");
1452 case FreeRDP_DeviceArray:
1454 freerdp_device_collection_free(settings);
1455 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DeviceArraySize, data,
1457 case FreeRDP_ChannelDefArray:
1458 if ((len > 0) && (len < CHANNEL_MAX_COUNT))
1460 "FreeRDP_ChannelDefArray::len expected to be >= %" PRIu32
1461 ", but have %" PRIu32,
1462 CHANNEL_MAX_COUNT, len);
1463 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ChannelDefArray,
1464 FreeRDP_ChannelDefArraySize, data, len,
1466 case FreeRDP_MonitorDefArray:
1467 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_MonitorDefArraySize,
1469 case FreeRDP_ClientAutoReconnectCookie:
1470 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1472 case FreeRDP_ServerAutoReconnectCookie:
1473 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1475 case FreeRDP_ClientTimeZone:
1478 WLog_ERR(TAG,
"FreeRDP_ClientTimeZone::len must be 0 or 1");
1481 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1483 case FreeRDP_BitmapCacheV2CellInfo:
1484 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_BitmapCacheV2NumCells,
1486 case FreeRDP_GlyphCache:
1487 if ((len != 0) && (len != 10))
1489 WLog_ERR(TAG,
"FreeRDP_GlyphCache::len must be 0 or 10");
1492 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1494 case FreeRDP_FragCache:
1497 WLog_ERR(TAG,
"FreeRDP_FragCache::len must be 0 or 1");
1500 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1502 case FreeRDP_StaticChannelArray:
1504 freerdp_static_channel_collection_free(settings);
1505 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_StaticChannelArraySize,
1507 case FreeRDP_DynamicChannelArray:
1509 freerdp_dynamic_channel_collection_free(settings);
1510 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DynamicChannelArraySize,
1512 case FreeRDP_ReceivedCapabilityData:
1514 freerdp_capability_buffer_free(settings);
1515 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ReceivedCapabilitiesSize,
1516 data, len,
sizeof(BYTE*));
1517 case FreeRDP_ReceivedCapabilities:
1519 freerdp_capability_buffer_free(settings);
1520 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ReceivedCapabilitiesSize,
1521 data, len,
sizeof(
char));
1522 case FreeRDP_OrderSupport:
1523 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_UINT32_UNUSED, data, len,
1526 case FreeRDP_MonitorIds:
1527 return freerdp_settings_set_pointer_len_(
1528 settings, FreeRDP_MonitorIds, FreeRDP_NumMonitorIds, data, len,
sizeof(UINT32));
1531 if ((data == NULL) && (len == 0))
1536 WLog_WARN(TAG,
"Invalid id %" PRIuz,
id);
1541void* freerdp_settings_get_pointer_array_writable(
const rdpSettings* settings,
1542 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
1549 case FreeRDP_ClientAutoReconnectCookie:
1551 if ((offset >= max) || !settings->ClientAutoReconnectCookie)
1553 return &settings->ClientAutoReconnectCookie[offset];
1554 case FreeRDP_ServerAutoReconnectCookie:
1556 if ((offset >= max) || !settings->ServerAutoReconnectCookie)
1558 return &settings->ServerAutoReconnectCookie[offset];
1559 case FreeRDP_ServerCertificate:
1563 return &settings->ServerCertificate[offset];
1564 case FreeRDP_ServerRandom:
1568 return &settings->ServerRandom[offset];
1569 case FreeRDP_ClientRandom:
1573 return &settings->ClientRandom[offset];
1574 case FreeRDP_LoadBalanceInfo:
1578 return &settings->LoadBalanceInfo[offset];
1580 case FreeRDP_RedirectionTsvUrl:
1584 return &settings->RedirectionTsvUrl[offset];
1586 case FreeRDP_RedirectionPassword:
1590 return &settings->RedirectionPassword[offset];
1592 case FreeRDP_OrderSupport:
1596 return &settings->OrderSupport[offset];
1597 case FreeRDP_MonitorIds:
1601 return &settings->MonitorIds[offset];
1602 case FreeRDP_MonitorDefArray:
1606 return &settings->MonitorDefArray[offset];
1607 case FreeRDP_ChannelDefArray:
1611 return &settings->ChannelDefArray[offset];
1612 case FreeRDP_DeviceArray:
1616 return settings->DeviceArray[offset];
1617 case FreeRDP_StaticChannelArray:
1621 return settings->StaticChannelArray[offset];
1622 case FreeRDP_DynamicChannelArray:
1626 return settings->DynamicChannelArray[offset];
1627 case FreeRDP_FragCache:
1631 return &settings->FragCache[offset];
1632 case FreeRDP_GlyphCache:
1636 return &settings->GlyphCache[offset];
1637 case FreeRDP_BitmapCacheV2CellInfo:
1641 return &settings->BitmapCacheV2CellInfo[offset];
1642 case FreeRDP_ReceivedCapabilities:
1646 return &settings->ReceivedCapabilities[offset];
1647 case FreeRDP_TargetNetAddresses:
1651 return settings->TargetNetAddresses[offset];
1652 case FreeRDP_TargetNetPorts:
1656 return &settings->TargetNetPorts[offset];
1657 case FreeRDP_ClientTimeZone:
1661 return settings->ClientTimeZone;
1662 case FreeRDP_RdpServerCertificate:
1666 return settings->RdpServerCertificate;
1667 case FreeRDP_RdpServerRsaKey:
1671 return settings->RdpServerRsaKey;
1678 WLog_WARN(TAG,
"Invalid offset for %s [%" PRIuz
"]: size=%" PRIuz
", offset=%" PRIuz,
1683BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1684 size_t offset,
const void* data)
1686 size_t maxOffset = 0;
1691 case FreeRDP_ClientAutoReconnectCookie:
1693 if ((offset >= maxOffset) || !data || !settings->ClientAutoReconnectCookie)
1697 case FreeRDP_ServerAutoReconnectCookie:
1699 if ((offset >= maxOffset) || !data || !settings->ServerAutoReconnectCookie)
1703 case FreeRDP_ServerCertificate:
1705 if ((offset >= maxOffset) || !data)
1707 settings->ServerCertificate[offset] = *(
const BYTE*)data;
1709 case FreeRDP_DeviceArray:
1711 if (offset >= maxOffset)
1713 freerdp_device_free(settings->DeviceArray[offset]);
1714 settings->DeviceArray[offset] = freerdp_device_clone(data);
1716 case FreeRDP_TargetNetAddresses:
1718 if ((offset >= maxOffset) || !data)
1720 free(settings->TargetNetAddresses[offset]);
1721 settings->TargetNetAddresses[offset] = _strdup((
const char*)data);
1722 return settings->TargetNetAddresses[offset] != NULL;
1723 case FreeRDP_TargetNetPorts:
1725 if ((offset >= maxOffset) || !data)
1727 settings->TargetNetPorts[offset] = *((
const UINT32*)data);
1729 case FreeRDP_StaticChannelArray:
1731 if ((offset >= maxOffset) || !data)
1733 freerdp_addin_argv_free(settings->StaticChannelArray[offset]);
1734 settings->StaticChannelArray[offset] = freerdp_addin_argv_clone(data);
1736 case FreeRDP_DynamicChannelArray:
1738 if ((offset >= maxOffset) || !data)
1740 freerdp_addin_argv_free(settings->DynamicChannelArray[offset]);
1741 settings->DynamicChannelArray[offset] = freerdp_addin_argv_clone(data);
1743 case FreeRDP_BitmapCacheV2CellInfo:
1745 if ((offset >= maxOffset) || !data)
1749 settings->BitmapCacheV2CellInfo[offset] = *cdata;
1752 case FreeRDP_ServerRandom:
1754 if ((offset >= maxOffset) || !data)
1756 settings->ServerRandom[offset] = *(
const BYTE*)data;
1758 case FreeRDP_ClientRandom:
1760 if ((offset >= maxOffset) || !data)
1762 settings->ClientRandom[offset] = *(
const BYTE*)data;
1764 case FreeRDP_LoadBalanceInfo:
1766 if ((offset >= maxOffset) || !data)
1768 settings->LoadBalanceInfo[offset] = *(
const BYTE*)data;
1770 case FreeRDP_RedirectionTsvUrl:
1772 if ((offset >= maxOffset) || !data)
1774 settings->RedirectionTsvUrl[offset] = *(
const BYTE*)data;
1776 case FreeRDP_RedirectionPassword:
1778 if ((offset >= maxOffset) || !data)
1780 settings->RedirectionPassword[offset] = *(
const BYTE*)data;
1782 case FreeRDP_OrderSupport:
1784 if (!settings->OrderSupport)
1786 if ((offset >= maxOffset) || !data)
1788 settings->OrderSupport[offset] = *(
const BOOL*)data ? 1 : 0;
1790 case FreeRDP_GlyphCache:
1792 if (!settings->GlyphCache)
1794 if ((offset >= maxOffset) || !data)
1798 case FreeRDP_FragCache:
1800 if (!settings->FragCache)
1802 if ((offset >= maxOffset) || !data)
1806 case FreeRDP_MonitorIds:
1808 if ((offset >= maxOffset) || !data)
1810 settings->MonitorIds[offset] = *(
const UINT32*)data;
1812 case FreeRDP_ChannelDefArray:
1814 if ((offset >= maxOffset) || !data)
1816 settings->ChannelDefArray[offset] = *(
const CHANNEL_DEF*)data;
1818 case FreeRDP_MonitorDefArray:
1820 if ((offset >= maxOffset) || !data)
1822 settings->MonitorDefArray[offset] = *(
const rdpMonitor*)data;
1825 case FreeRDP_ClientTimeZone:
1827 if ((offset >= maxOffset) || !data || !settings->ClientTimeZone)
1838 WLog_WARN(TAG,
"[%s] Invalid offset=%" PRIuz
" [%" PRIuz
"] or NULL data=%p",
1843const void* freerdp_settings_get_pointer_array(
const rdpSettings* settings,
1844 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
1846 return freerdp_settings_get_pointer_array_writable(settings,
id, offset);
1851 UINT32 flags = FREERDP_CODEC_ALL;
1852 if (settings->RemoteFxCodec == FALSE)
1854 flags &= (uint32_t)~FREERDP_CODEC_REMOTEFX;
1856 if (settings->NSCodec == FALSE)
1858 flags &= (uint32_t)~FREERDP_CODEC_NSCODEC;
1866 WINPR_ASSERT(settings);
1867 const char* hostname = settings->ServerHostname;
1869 if (settings->UserSpecifiedServerName)
1870 hostname = settings->UserSpecifiedServerName;
1875#if defined(WITH_FREERDP_DEPRECATED)
1878 return freerdp_addin_argv_clone(channel);
1883 return freerdp_addin_argv_clone(channel);
1887BOOL freerdp_target_net_addresses_copy(rdpSettings* settings,
char** addresses, UINT32 count)
1889 WINPR_ASSERT(settings);
1890 WINPR_ASSERT(addresses);
1892 if (!freerdp_target_net_adresses_reset(settings, count))
1895 for (UINT32 i = 0; i < settings->TargetNetAddressCount; i++)
1897 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i,
1900 freerdp_target_net_addresses_free(settings);
1910 if (!what && !expect)
1912 if (!what || !expect)
1915 if (what->Id != expect->Id)
1917 if (what->Type != expect->Type)
1919 if (what->Name && expect->Name)
1921 if (strcmp(what->Name, expect->Name) != 0)
1926 if (what->Name != expect->Name)
1932 case RDPDR_DTYP_PRINT:
1936 if (a->DriverName && b->DriverName)
1937 return strcmp(a->DriverName, b->DriverName) == 0;
1938 return a->DriverName == b->DriverName;
1941 case RDPDR_DTYP_SERIAL:
1946 if (a->Path && b->Path)
1948 if (strcmp(a->Path, b->Path) != 0)
1951 else if (a->Path != b->Path)
1954 if (a->Driver && b->Driver)
1956 if (strcmp(a->Driver, b->Driver) != 0)
1959 else if (a->Driver != b->Driver)
1961 if (a->Permissive && b->Permissive)
1962 return strcmp(a->Permissive, b->Permissive) == 0;
1963 return a->Permissive == b->Permissive;
1966 case RDPDR_DTYP_PARALLEL:
1970 if (a->Path && b->Path)
1971 return strcmp(a->Path, b->Path) == 0;
1972 return a->Path == b->Path;
1975 case RDPDR_DTYP_SMARTCARD:
1977 case RDPDR_DTYP_FILESYSTEM:
1981 if (a->automount != b->automount)
1983 if (a->Path && b->Path)
1984 return strcmp(a->Path, b->Path) == 0;
1985 return a->Path == b->Path;
1998 RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
1999 RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
2000 RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED |
2001 RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED;
2003 if (flags & RAIL_LEVEL_SUPPORTED)
2004 winpr_str_append(
"RAIL_LEVEL_SUPPORTED", buffer, length,
"|");
2005 if (flags & RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED)
2006 winpr_str_append(
"RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED", buffer, length,
"|");
2007 if (flags & RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED)
2008 winpr_str_append(
"RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED", buffer, length,
"|");
2009 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2010 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
2011 if (flags & RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED)
2012 winpr_str_append(
"RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED", buffer, length,
"|");
2013 if (flags & RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED)
2014 winpr_str_append(
"RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED", buffer, length,
"|");
2015 if (flags & RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED)
2016 winpr_str_append(
"RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED", buffer, length,
"|");
2017 if (flags & RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED)
2018 winpr_str_append(
"RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED", buffer, length,
"|");
2019 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2020 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
2021 if ((flags & ~mask) != 0)
2023 char tbuffer[64] = { 0 };
2024 (void)_snprintf(tbuffer,
sizeof(tbuffer),
"RAIL_FLAG_UNKNOWN 0x%08" PRIx32, flags & mask);
2025 winpr_str_append(tbuffer, buffer, length,
"|");
2031 const BYTE** capsData,
const UINT32* capsSizes,
2032 UINT32 capsCount, BOOL serverReceivedCaps)
2034 WINPR_ASSERT(settings);
2035 WINPR_ASSERT(capsFlags || (capsCount == 0));
2036 WINPR_ASSERT(capsData || (capsCount == 0));
2037 WINPR_ASSERT(capsSizes || (capsCount == 0));
2038 WINPR_ASSERT(capsCount <= UINT16_MAX);
2040 for (UINT32 x = 0; x < capsCount; x++)
2045 wStream* sub = Stream_StaticConstInit(&buffer, capsData[x], capsSizes[x]);
2047 if (!rdp_read_capability_set(sub, (UINT16)x, settings, serverReceivedCaps))
2060 return "RDP_VERSION_4";
2061 case RDP_VERSION_5_PLUS:
2062 return "RDP_VERSION_5_PLUS";
2063 case RDP_VERSION_10_0:
2064 return "RDP_VERSION_10_0";
2065 case RDP_VERSION_10_1:
2066 return "RDP_VERSION_10_1";
2067 case RDP_VERSION_10_2:
2068 return "RDP_VERSION_10_2";
2069 case RDP_VERSION_10_3:
2070 return "RDP_VERSION_10_3";
2071 case RDP_VERSION_10_4:
2072 return "RDP_VERSION_10_4";
2073 case RDP_VERSION_10_5:
2074 return "RDP_VERSION_10_5";
2075 case RDP_VERSION_10_6:
2076 return "RDP_VERSION_10_6";
2077 case RDP_VERSION_10_7:
2078 return "RDP_VERSION_10_7";
2079 case RDP_VERSION_10_8:
2080 return "RDP_VERSION_10_8";
2081 case RDP_VERSION_10_9:
2082 return "RDP_VERSION_10_9";
2083 case RDP_VERSION_10_10:
2084 return "RDP_VERSION_10_10";
2085 case RDP_VERSION_10_11:
2086 return "RDP_VERSION_10_11";
2087 case RDP_VERSION_10_12:
2088 return "RDP_VERSION_10_12";
2090 return "RDP_VERSION_UNKNOWN";
2097 WINPR_ASSERT(settings);
2100 return freerdp_settings_set_string_copy_(settings,
id, NULL, 0, TRUE);
2104 char* str = ConvertWCharToUtf8Alloc(param, &len);
2105 if (!str && (len != 0))
2108 return freerdp_settings_set_string_(settings,
id, str, len);
2112 const WCHAR* param,
size_t length)
2116 WINPR_ASSERT(settings);
2119 return freerdp_settings_set_string_copy_(settings,
id, NULL, length, TRUE);
2121 char* str = ConvertWCharNToUtf8Alloc(param, length, &len);
2122 if (!str && (length != 0))
2126 const size_t wlen = _wcsnlen(param, length);
2131 return freerdp_settings_set_string_(settings,
id, str, len);
2135 FreeRDP_Settings_Keys_String
id,
size_t* pCharLen)
2142 return ConvertUtf8ToWCharAlloc(str, pCharLen);
2149 case RDPDR_DTYP_FILESYSTEM:
2150 return "RDPDR_DTYP_FILESYSTEM";
2151 case RDPDR_DTYP_PARALLEL:
2152 return "RDPDR_DTYP_PARALLEL";
2153 case RDPDR_DTYP_PRINT:
2154 return "RDPDR_DTYP_PRINT";
2155 case RDPDR_DTYP_SERIAL:
2156 return "RDPDR_DTYP_SERIAL";
2157 case RDPDR_DTYP_SMARTCARD:
2158 return "RDPDR_DTYP_SMARTCARD";
2160 return "RDPDR_DTYP_UNKNOWN";
2164const char* freerdp_encryption_level_string(UINT32 EncryptionLevel)
2166 switch (EncryptionLevel)
2168 case ENCRYPTION_LEVEL_NONE:
2169 return "ENCRYPTION_LEVEL_NONE";
2170 case ENCRYPTION_LEVEL_LOW:
2171 return "ENCRYPTION_LEVEL_LOW";
2172 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
2173 return "ENCRYPTION_LEVEL_CLIENT_COMPATIBLE";
2174 case ENCRYPTION_LEVEL_HIGH:
2175 return "ENCRYPTION_LEVEL_HIGH";
2176 case ENCRYPTION_LEVEL_FIPS:
2177 return "ENCRYPTION_LEVEL_FIPS";
2179 return "ENCRYPTION_LEVEL_UNKNOWN";
2183const char* freerdp_encryption_methods_string(UINT32 EncryptionMethods,
char* buffer,
size_t size)
2185 if (EncryptionMethods == ENCRYPTION_METHOD_NONE)
2187 winpr_str_append(
"ENCRYPTION_METHOD_NONE", buffer, size,
"|");
2191 if (EncryptionMethods & ENCRYPTION_METHOD_40BIT)
2193 winpr_str_append(
"ENCRYPTION_METHOD_40BIT", buffer, size,
"|");
2195 if (EncryptionMethods & ENCRYPTION_METHOD_128BIT)
2197 winpr_str_append(
"ENCRYPTION_METHOD_128BIT", buffer, size,
"|");
2199 if (EncryptionMethods & ENCRYPTION_METHOD_56BIT)
2201 winpr_str_append(
"ENCRYPTION_METHOD_56BIT", buffer, size,
"|");
2203 if (EncryptionMethods & ENCRYPTION_METHOD_FIPS)
2205 winpr_str_append(
"ENCRYPTION_METHOD_FIPS", buffer, size,
"|");
2213 const UINT32 invalid = mask & ~(RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
2214 RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT);
2216 if (mask & RNS_UD_32BPP_SUPPORT)
2217 winpr_str_append(
"RNS_UD_32BPP_SUPPORT", buffer, size,
"|");
2218 if (mask & RNS_UD_24BPP_SUPPORT)
2219 winpr_str_append(
"RNS_UD_24BPP_SUPPORT", buffer, size,
"|");
2220 if (mask & RNS_UD_16BPP_SUPPORT)
2221 winpr_str_append(
"RNS_UD_16BPP_SUPPORT", buffer, size,
"|");
2222 if (mask & RNS_UD_15BPP_SUPPORT)
2223 winpr_str_append(
"RNS_UD_15BPP_SUPPORT", buffer, size,
"|");
2227 char str[32] = { 0 };
2228 (void)_snprintf(str,
sizeof(str),
"RNS_UD_INVALID[0x%04" PRIx32
"]", invalid);
2229 winpr_str_append(str, buffer, size,
"|");
2231 char hex[32] = { 0 };
2232 (void)_snprintf(hex,
sizeof(hex),
"[0x%04" PRIx16
"]", mask);
2237 const char* separator,
const char* param)
2245 winpr_asprintf(&str, &len,
"%s", param);
2246 else if (!separator)
2247 winpr_asprintf(&str, &len,
"%s%s", old, param);
2249 winpr_asprintf(&str, &len,
"%s%s%s", old, separator, param);
2258 return settings != NULL;
2265static int sort_monitor_fn(
const void* pva,
const void* pvb)
2271 if (a->is_primary && b->is_primary)
2288 WINPR_ASSERT(monitors || (count == 0));
2303 for (
size_t x = 0; x < count; x++)
2306 if (cur->is_primary)
2314 for (
size_t x = 0; x < count; x++)
2317 if ((cur->x == 0) && (cur->y == 0))
2327 WLog_ERR(TAG,
"Could not find primary monitor, aborting");
2334 WINPR_ASSERT(sorted);
2339 sorted[sortpos] = *primary;
2340 sorted[sortpos].x = 0;
2341 sorted[sortpos].y = 0;
2342 sorted[sortpos].is_primary = TRUE;
2346 const INT32 offsetX = primary->x;
2347 const INT32 offsetY = primary->y;
2353 for (
size_t x = 0; x < count; x++)
2362 sorted[sortpos++] = m;
2366 qsort(sorted, count,
sizeof(
rdpMonitor), sort_monitor_fn);
2369 WINPR_ASSERTING_INT_CAST(uint32_t, count));
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
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.
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_*.
BOOL freerdp_settings_set_monitor_def_array_sorted(rdpSettings *settings, const rdpMonitor *monitors, size_t count)
Sort monitor array according to:
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 BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.