23 #include <freerdp/config.h>
30 #include <winpr/crt.h>
31 #include <winpr/assert.h>
33 #include "../core/settings.h"
34 #include "../core/capabilities.h"
36 #include <freerdp/crypto/certificate.h>
37 #include <freerdp/settings.h>
38 #include <freerdp/freerdp.h>
39 #include <freerdp/log.h>
41 #define TAG FREERDP_TAG("common")
43 BOOL freerdp_addin_argv_add_argument_ex(
ADDIN_ARGV* args,
const char* argument,
size_t len)
46 char** new_argv = NULL;
48 if (!args || !argument)
52 len = strlen(argument);
54 new_argv = (
char**)realloc(args->argv,
sizeof(
char*) * (args->argc + 1));
59 args->argv = new_argv;
61 str = calloc(len + 1,
sizeof(
char));
64 memcpy(str, argument, len);
65 args->argv[args->argc++] = str;
69 BOOL freerdp_addin_argv_add_argument(
ADDIN_ARGV* args,
const char* argument)
71 return freerdp_addin_argv_add_argument_ex(args, argument, 0);
74 BOOL 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(&args->argv[x], (args->argc - x) *
sizeof(
char*), &args->argv[x + 1],
85 (args->argc - x - 1) *
sizeof(
char*));
86 args->argv[args->argc - 1] = NULL;
94 int freerdp_addin_set_argument(
ADDIN_ARGV* args,
const char* argument)
96 if (!args || !argument)
99 for (
int i = 0; i < args->argc; i++)
101 if (strcmp(args->argv[i], argument) == 0)
107 if (!freerdp_addin_argv_add_argument(args, argument))
112 int freerdp_addin_replace_argument(
ADDIN_ARGV* args,
const char* previous,
const char* argument)
114 if (!args || !previous || !argument)
117 for (
int i = 0; i < args->argc; i++)
119 if (strcmp(args->argv[i], previous) == 0)
123 if (!(args->argv[i] = _strdup(argument)))
130 if (!freerdp_addin_argv_add_argument(args, argument))
135 int freerdp_addin_set_argument_value(
ADDIN_ARGV* args,
const char* option,
const char* value)
141 if (!args || !option || !value)
143 length = strlen(option) + strlen(value) + 1;
144 str = (
char*)calloc(length + 1,
sizeof(
char));
149 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
151 for (
int i = 0; i < args->argc; i++)
153 p = strchr(args->argv[i],
':');
157 if (strncmp(args->argv[i], option, p - args->argv[i]) == 0)
166 rc = freerdp_addin_argv_add_argument(args, str);
173 int freerdp_addin_replace_argument_value(
ADDIN_ARGV* args,
const char* previous,
const char* option,
179 if (!args || !previous || !option || !value)
181 length = strlen(option) + strlen(value) + 1;
182 str = (
char*)calloc(length + 1,
sizeof(
char));
187 (void)sprintf_s(str, length + 1,
"%s:%s", option, value);
189 for (
int i = 0; i < args->argc; i++)
191 if (strcmp(args->argv[i], previous) == 0)
199 rc = freerdp_addin_argv_add_argument(args, str);
206 BOOL freerdp_device_collection_add(rdpSettings* settings,
RDPDR_DEVICE* device)
210 WINPR_ASSERT(settings);
211 WINPR_ASSERT(device);
217 UINT32 new_size = old * 2;
221 new_size = count * 2;
229 settings->DeviceArray = new_array;
230 memset(&settings->DeviceArray[old], 0, (new_size - old) *
sizeof(
RDPDR_DEVICE*));
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--;
267 RDPDR_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)
287 RDPDR_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)
303 RDPDR_DEVICE* freerdp_device_new(UINT32 Type,
size_t count,
const char* 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 };
495 args[0] = device->Name;
498 switch (device->Type)
500 case RDPDR_DTYP_FILESYSTEM:
503 args[1] = src.drive->Path;
508 case RDPDR_DTYP_PRINT:
509 if (src.printer->DriverName)
511 args[1] = src.printer->DriverName;
516 case RDPDR_DTYP_SMARTCARD:
519 case RDPDR_DTYP_SERIAL:
520 if (src.serial->Path)
522 args[1] = src.serial->Path;
526 if (src.serial->Driver)
528 args[2] = src.serial->Driver;
532 if (src.serial->Permissive)
534 args[3] = src.serial->Permissive;
539 case RDPDR_DTYP_PARALLEL:
540 if (src.parallel->Path)
542 args[1] = src.parallel->Path;
547 WLog_ERR(TAG,
"unknown device type %" PRIu32
"", device->Type);
551 copy.dev = freerdp_device_new(device->Type, count, args);
555 copy.dev->Id = device->Id;
560 void freerdp_device_collection_free(rdpSettings* settings)
562 WINPR_ASSERT(settings);
564 if (settings->DeviceArray)
566 for (UINT32 index = 0; index < settings->DeviceArraySize; index++)
567 (
void)freerdp_settings_set_pointer_array(settings, FreeRDP_DeviceArray, index, NULL);
570 free(settings->DeviceArray);
577 BOOL freerdp_static_channel_collection_del(rdpSettings* settings,
const char* name)
580 if (!settings || !settings->StaticChannelArray)
583 for (UINT32 x = 0; x < count; x++)
585 ADDIN_ARGV* cur = settings->StaticChannelArray[x];
586 if (cur && (cur->argc > 0))
588 if (strcmp(name, cur->argv[0]) == 0)
590 const size_t rem = settings->StaticChannelArraySize - count + 1;
591 memmove_s(&settings->StaticChannelArray[x], (count - x) *
sizeof(
ADDIN_ARGV*),
592 &settings->StaticChannelArray[x + 1],
594 memset(&settings->StaticChannelArray[count - 1], 0,
sizeof(
ADDIN_ARGV*) * rem);
596 freerdp_addin_argv_free(cur);
602 const size_t rem = settings->StaticChannelArraySize - count;
603 memset(&settings->StaticChannelArray[count], 0,
sizeof(
ADDIN_ARGV*) * rem);
608 BOOL freerdp_static_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
612 WINPR_ASSERT(settings);
613 WINPR_ASSERT(channel);
618 const UINT32 oldSize =
620 UINT32 new_size = oldSize * 2ul;
623 new_size = count * 2ul;
631 settings->StaticChannelArray = new_array;
633 const size_t rem = new_size - oldSize;
634 memset(&settings->StaticChannelArray[oldSize], 0,
sizeof(
ADDIN_ARGV*) * rem);
642 ADDIN_ARGV** cur = &settings->StaticChannelArray[count++];
643 freerdp_addin_argv_free(*cur);
648 ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings,
const char* name)
652 WINPR_ASSERT(settings);
655 for (UINT32 index = 0;
658 channel = settings->StaticChannelArray[index];
660 if (strcmp(channel->argv[0], name) == 0)
667 void freerdp_static_channel_collection_free(rdpSettings* settings)
672 if (settings->StaticChannelArray)
676 freerdp_addin_argv_free(settings->StaticChannelArray[i]);
679 free(settings->StaticChannelArray);
681 settings->StaticChannelArray = NULL;
685 BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings,
const char* name)
688 if (!settings || !settings->DynamicChannelArray)
691 for (UINT32 x = 0; x < count; x++)
693 ADDIN_ARGV* cur = settings->DynamicChannelArray[x];
694 if (cur && (cur->argc > 0))
696 if (strcmp(name, cur->argv[0]) == 0)
698 const size_t rem = settings->DynamicChannelArraySize - count + 1;
699 memmove_s(&settings->DynamicChannelArray[x], (count - x) *
sizeof(
ADDIN_ARGV*),
700 &settings->DynamicChannelArray[x + 1],
702 memset(&settings->DynamicChannelArray[count - 1], 0,
sizeof(
ADDIN_ARGV*) * rem);
704 freerdp_addin_argv_free(cur);
714 BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings,
ADDIN_ARGV* channel)
719 WINPR_ASSERT(settings);
720 WINPR_ASSERT(channel);
727 UINT32 size = oldSize * 2;
731 new_array = realloc(settings->DynamicChannelArray,
sizeof(
ADDIN_ARGV*) * size);
736 settings->DynamicChannelArray = new_array;
738 const size_t rem = size - oldSize;
739 memset(&settings->DynamicChannelArray[oldSize], 0,
sizeof(
ADDIN_ARGV*) * rem);
746 settings->DynamicChannelArray[count++] = channel;
750 ADDIN_ARGV* freerdp_dynamic_channel_collection_find(
const rdpSettings* settings,
const char* name)
752 WINPR_ASSERT(settings);
755 for (UINT32 index = 0;
758 ADDIN_ARGV* channel = settings->DynamicChannelArray[index];
760 if (strcmp(channel->argv[0], name) == 0)
767 void freerdp_addin_argv_free(
ADDIN_ARGV* args)
774 for (
int index = 0; index < args->argc; index++)
775 free(args->argv[index]);
782 ADDIN_ARGV* freerdp_addin_argv_new(
size_t argc,
const char* argv[])
791 args->argv = calloc(argc,
sizeof(
char*));
797 for (
size_t x = 0; x < argc; x++)
799 args->argv[x] = _strdup(argv[x]);
807 freerdp_addin_argv_free(args);
821 return freerdp_addin_argv_new(args->argc, cnv.cc);
824 void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
826 WINPR_ASSERT(settings);
828 if (settings->DynamicChannelArray)
832 freerdp_addin_argv_free(settings->DynamicChannelArray[i]);
835 free(settings->DynamicChannelArray);
837 settings->DynamicChannelArray = NULL;
841 void freerdp_capability_buffer_free(rdpSettings* settings)
843 WINPR_ASSERT(settings);
845 if (settings->ReceivedCapabilityData)
847 for (UINT32 x = 0; x < settings->ReceivedCapabilitiesSize; x++)
849 free(settings->ReceivedCapabilityData[x]);
850 settings->ReceivedCapabilityData[x] = NULL;
853 settings->ReceivedCapabilitiesSize = 0;
855 free(settings->ReceivedCapabilityDataSizes);
856 settings->ReceivedCapabilityDataSizes = NULL;
858 free(settings->ReceivedCapabilityData);
859 settings->ReceivedCapabilityData = NULL;
860 free(settings->ReceivedCapabilities);
861 settings->ReceivedCapabilities = NULL;
864 BOOL freerdp_capability_buffer_copy(rdpSettings* settings,
const rdpSettings* src)
866 WINPR_ASSERT(settings);
869 if (!freerdp_capability_buffer_allocate(settings, src->ReceivedCapabilitiesSize))
872 for (UINT32 x = 0; x < src->ReceivedCapabilitiesSize; x++)
874 WINPR_ASSERT(settings->ReceivedCapabilities);
875 settings->ReceivedCapabilities[x] = src->ReceivedCapabilities[x];
877 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
878 settings->ReceivedCapabilityDataSizes[x] = src->ReceivedCapabilityDataSizes[x];
880 WINPR_ASSERT(settings->ReceivedCapabilityData);
881 if (src->ReceivedCapabilityDataSizes[x] > 0)
883 void* tmp = realloc(settings->ReceivedCapabilityData[x],
884 settings->ReceivedCapabilityDataSizes[x]);
887 memcpy(tmp, src->ReceivedCapabilityData[x], src->ReceivedCapabilityDataSizes[x]);
888 settings->ReceivedCapabilityData[x] = tmp;
892 free(settings->ReceivedCapabilityData[x]);
893 settings->ReceivedCapabilityData[x] = NULL;
899 void freerdp_target_net_addresses_free(rdpSettings* settings)
901 WINPR_ASSERT(settings);
903 if (settings->TargetNetAddresses)
905 for (UINT32 index = 0; index < settings->TargetNetAddressCount; index++)
906 free(settings->TargetNetAddresses[index]);
909 free(settings->TargetNetAddresses);
910 free(settings->TargetNetPorts);
911 settings->TargetNetAddressCount = 0;
912 settings->TargetNetAddresses = NULL;
913 settings->TargetNetPorts = NULL;
916 void freerdp_server_license_issuers_free(rdpSettings* settings)
918 WINPR_ASSERT(settings);
920 if (settings->ServerLicenseProductIssuers)
922 for (UINT32 x = 0; x < settings->ServerLicenseProductIssuersCount; x++)
923 free(settings->ServerLicenseProductIssuers[x]);
925 free(settings->ServerLicenseProductIssuers);
926 settings->ServerLicenseProductIssuers = NULL;
927 settings->ServerLicenseProductIssuersCount = 0;
930 BOOL freerdp_server_license_issuers_copy(rdpSettings* settings,
char** issuers, UINT32 count)
932 WINPR_ASSERT(settings);
933 WINPR_ASSERT(issuers || (count == 0));
939 for (UINT32 x = 0; x < count; x++)
941 char* issuer = _strdup(issuers[x]);
944 settings->ServerLicenseProductIssuers[x] = issuer;
950 void freerdp_performance_flags_make(rdpSettings* settings)
952 UINT32 PerformanceFlags = PERF_FLAG_NONE;
955 PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING;
958 PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION;
961 PerformanceFlags |= PERF_DISABLE_WALLPAPER;
964 PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG;
967 PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS;
970 PerformanceFlags |= PERF_DISABLE_THEMING;
974 void freerdp_performance_flags_split(rdpSettings* settings)
977 settings, FreeRDP_AllowFontSmoothing,
979 PERF_ENABLE_FONT_SMOOTHING)
983 settings, FreeRDP_AllowDesktopComposition,
985 PERF_ENABLE_DESKTOP_COMPOSITION)
989 settings, FreeRDP_DisableWallpaper,
994 settings, FreeRDP_DisableFullWindowDrag,
996 PERF_DISABLE_FULLWINDOWDRAG)
1000 settings, FreeRDP_DisableMenuAnims,
1002 PERF_DISABLE_MENUANIMATIONS)
1006 settings, FreeRDP_DisableThemes,
1017 if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT)
1023 else if (GatewayUsageMethod == TSC_PROXY_MODE_DIRECT)
1029 else if (GatewayUsageMethod == TSC_PROXY_MODE_DETECT)
1035 else if (GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT)
1046 else if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT)
1056 void freerdp_update_gateway_usage_method(rdpSettings* settings, UINT32 GatewayEnabled,
1057 UINT32 GatewayBypassLocal)
1059 UINT32 GatewayUsageMethod = 0;
1061 if (!GatewayEnabled && !GatewayBypassLocal)
1062 GatewayUsageMethod = TSC_PROXY_MODE_NONE_DIRECT;
1063 else if (GatewayEnabled && !GatewayBypassLocal)
1064 GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
1065 else if (GatewayEnabled && GatewayBypassLocal)
1066 GatewayUsageMethod = TSC_PROXY_MODE_DETECT;
1071 #if defined(WITH_FREERDP_DEPRECATED)
1072 BOOL freerdp_get_param_bool(
const rdpSettings* settings,
int id)
1077 int freerdp_set_param_bool(rdpSettings* settings,
int id, BOOL param)
1082 int freerdp_get_param_int(
const rdpSettings* settings,
int id)
1087 int freerdp_set_param_int(rdpSettings* settings,
int id,
int param)
1092 UINT32 freerdp_get_param_uint32(
const rdpSettings* settings,
int id)
1097 int freerdp_set_param_uint32(rdpSettings* settings,
int id, UINT32 param)
1102 UINT64 freerdp_get_param_uint64(
const rdpSettings* settings,
int id)
1107 int freerdp_set_param_uint64(rdpSettings* settings,
int id, UINT64 param)
1112 char* freerdp_get_param_string(
const rdpSettings* settings,
int id)
1117 int freerdp_set_param_string(rdpSettings* settings,
int id,
const char* param)
1123 static BOOL value_to_uint(
const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
1125 char* endptr = NULL;
1126 unsigned long long rc = 0;
1128 if (!value || !result)
1132 rc = _strtoui64(value, &endptr, 0);
1137 if (endptr == value)
1140 if ((rc < min) || (rc > max))
1147 static BOOL value_to_int(
const char* value, LONGLONG* result, LONGLONG min, LONGLONG max)
1149 char* endptr = NULL;
1152 if (!value || !result)
1156 rc = _strtoi64(value, &endptr, 0);
1161 if (endptr == value)
1164 if ((rc < min) || (rc > max))
1171 static BOOL parsing_fail(
const char* key,
const char* type,
const char* value)
1173 WLog_ERR(TAG,
"Failed to parse key [%s] of type [%s]: value [%s]", key, type, value);
1177 BOOL freerdp_settings_set_value_for_name(rdpSettings* settings,
const char* name,
const char* value)
1183 if (!settings || !name)
1189 WLog_ERR(TAG,
"Invalid settings key [%s]", name);
1193 const SSIZE_T index = i;
1199 case RDP_SETTINGS_TYPE_BOOL:
1201 const BOOL val = (_strnicmp(value,
"TRUE", 5) == 0) || (_strnicmp(value,
"ON", 5) == 0);
1203 (_strnicmp(value,
"FALSE", 6) == 0) || (_strnicmp(value,
"OFF", 6) == 0);
1205 return parsing_fail(name,
"BOOL", value);
1208 case RDP_SETTINGS_TYPE_UINT16:
1209 if (!value_to_uint(value, &uval, 0, UINT16_MAX))
1210 return parsing_fail(name,
"UINT16", value);
1212 return parsing_fail(name,
"UINT16", value);
1215 case RDP_SETTINGS_TYPE_INT16:
1216 if (!value_to_int(value, &ival, INT16_MIN, INT16_MAX))
1217 return parsing_fail(name,
"INT16", value);
1219 return parsing_fail(name,
"INT16", value);
1221 case RDP_SETTINGS_TYPE_UINT32:
1222 if (!value_to_uint(value, &uval, 0, UINT32_MAX))
1223 return parsing_fail(name,
"UINT32", value);
1225 return parsing_fail(name,
"UINT32", value);
1227 case RDP_SETTINGS_TYPE_INT32:
1228 if (!value_to_int(value, &ival, INT32_MIN, INT32_MAX))
1229 return parsing_fail(name,
"INT32", value);
1231 return parsing_fail(name,
"INT32", value);
1233 case RDP_SETTINGS_TYPE_UINT64:
1234 if (!value_to_uint(value, &uval, 0, UINT64_MAX))
1235 return parsing_fail(name,
"UINT64", value);
1237 return parsing_fail(name,
"UINT64", value);
1239 case RDP_SETTINGS_TYPE_INT64:
1240 if (!value_to_int(value, &ival, INT64_MIN, INT64_MAX))
1241 return parsing_fail(name,
"INT64", value);
1243 return parsing_fail(name,
"INT64", value);
1246 case RDP_SETTINGS_TYPE_STRING:
1249 case RDP_SETTINGS_TYPE_POINTER:
1250 return parsing_fail(name,
"POINTER", value);
1257 BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1258 SSIZE_T lenId,
const void* data,
size_t len,
size_t size)
1274 copy = calloc(len, size);
1278 memcpy(copy, data, len * size);
1294 FreeRDP_Settings_Keys_Pointer
id)
1298 const rdpSettings* pc;
1306 const void* data,
size_t len)
1320 case FreeRDP_RdpServerCertificate:
1321 freerdp_certificate_free(settings->RdpServerCertificate);
1325 WLog_ERR(TAG,
"FreeRDP_RdpServerCertificate::len must be 0 or 1");
1328 settings->RdpServerCertificate = cnv.v;
1329 if (!settings->RdpServerCertificate && (len > 0))
1331 settings->RdpServerCertificate = freerdp_certificate_new();
1332 if (!settings->RdpServerCertificate)
1336 case FreeRDP_RdpServerRsaKey:
1337 freerdp_key_free(settings->RdpServerRsaKey);
1340 WLog_ERR(TAG,
"FreeRDP_RdpServerRsaKey::len must be 0 or 1");
1343 settings->RdpServerRsaKey = (rdpPrivateKey*)cnv.v;
1344 if (!settings->RdpServerRsaKey && (len > 0))
1346 settings->RdpServerRsaKey = freerdp_key_new();
1347 if (!settings->RdpServerRsaKey)
1351 case FreeRDP_RedirectionPassword:
1352 return freerdp_settings_set_pointer_len_(
1353 settings,
id, FreeRDP_RedirectionPasswordLength, data, len,
sizeof(
char));
1354 case FreeRDP_RedirectionTsvUrl:
1355 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionTsvUrlLength,
1356 data, len,
sizeof(
char));
1357 case FreeRDP_RedirectionTargetCertificate:
1358 freerdp_certificate_free(settings->RedirectionTargetCertificate);
1362 WLog_ERR(TAG,
"FreeRDP_RedirectionTargetCertificate::len must be 0 or 1");
1365 settings->RedirectionTargetCertificate = cnv.v;
1366 if (!settings->RedirectionTargetCertificate && (len > 0))
1368 settings->RedirectionTargetCertificate = freerdp_certificate_new();
1369 if (!settings->RedirectionTargetCertificate)
1373 case FreeRDP_RedirectionGuid:
1374 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_RedirectionGuidLength,
1375 data, len,
sizeof(BYTE));
1376 case FreeRDP_LoadBalanceInfo:
1377 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_LoadBalanceInfoLength,
1378 data, len,
sizeof(
char));
1379 case FreeRDP_ServerRandom:
1380 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerRandomLength, data,
1382 case FreeRDP_ClientRandom:
1383 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ClientRandomLength, data,
1385 case FreeRDP_ServerCertificate:
1386 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ServerCertificateLength,
1387 data, len,
sizeof(
char));
1388 case FreeRDP_TargetNetAddresses:
1389 if ((data == NULL) && (len == 0))
1391 freerdp_target_net_addresses_free(settings);
1396 "[BUG] FreeRDP_TargetNetAddresses must not be resized from outside the library!");
1398 case FreeRDP_ServerLicenseProductIssuers:
1400 freerdp_server_license_issuers_free(settings);
1401 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ServerLicenseProductIssuers,
1402 FreeRDP_ServerLicenseProductIssuersCount, data,
1403 len,
sizeof(
char*));
1404 case FreeRDP_TargetNetPorts:
1405 if ((data == NULL) && (len == 0))
1407 freerdp_target_net_addresses_free(settings);
1411 "[BUG] FreeRDP_TargetNetPorts must not be resized from outside the library!");
1413 case FreeRDP_DeviceArray:
1415 freerdp_device_collection_free(settings);
1416 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DeviceArraySize, data,
1418 case FreeRDP_ChannelDefArray:
1419 if ((len > 0) && (len < CHANNEL_MAX_COUNT))
1421 "FreeRDP_ChannelDefArray::len expected to be >= %" PRIu32
1422 ", but have %" PRIu32,
1423 CHANNEL_MAX_COUNT, len);
1424 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ChannelDefArray,
1425 FreeRDP_ChannelDefArraySize, data, len,
1427 case FreeRDP_MonitorDefArray:
1428 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_MonitorDefArraySize,
1430 case FreeRDP_ClientAutoReconnectCookie:
1431 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
1433 case FreeRDP_ServerAutoReconnectCookie:
1434 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
1436 case FreeRDP_ClientTimeZone:
1439 WLog_ERR(TAG,
"FreeRDP_ClientTimeZone::len must be 0 or 1");
1442 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
1444 case FreeRDP_BitmapCacheV2CellInfo:
1445 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_BitmapCacheV2NumCells,
1447 case FreeRDP_GlyphCache:
1448 if ((len != 0) && (len != 10))
1450 WLog_ERR(TAG,
"FreeRDP_GlyphCache::len must be 0 or 10");
1453 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
1455 case FreeRDP_FragCache:
1458 WLog_ERR(TAG,
"FreeRDP_FragCache::len must be 0 or 1");
1461 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
1463 case FreeRDP_StaticChannelArray:
1465 freerdp_static_channel_collection_free(settings);
1466 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_StaticChannelArraySize,
1468 case FreeRDP_DynamicChannelArray:
1470 freerdp_dynamic_channel_collection_free(settings);
1471 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_DynamicChannelArraySize,
1473 case FreeRDP_ReceivedCapabilityData:
1475 freerdp_capability_buffer_free(settings);
1476 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ReceivedCapabilitiesSize,
1477 data, len,
sizeof(BYTE*));
1478 case FreeRDP_ReceivedCapabilities:
1480 freerdp_capability_buffer_free(settings);
1481 return freerdp_settings_set_pointer_len_(settings,
id, FreeRDP_ReceivedCapabilitiesSize,
1482 data, len,
sizeof(
char));
1483 case FreeRDP_OrderSupport:
1484 return freerdp_settings_set_pointer_len_(settings,
id, -1, data, len,
sizeof(
char));
1486 case FreeRDP_MonitorIds:
1487 return freerdp_settings_set_pointer_len_(
1488 settings, FreeRDP_MonitorIds, FreeRDP_NumMonitorIds, data, len,
sizeof(UINT32));
1491 if ((data == NULL) && (len == 0))
1496 WLog_WARN(TAG,
"Invalid id %" PRIuz,
id);
1501 void* freerdp_settings_get_pointer_array_writable(
const rdpSettings* settings,
1502 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
1509 case FreeRDP_ClientAutoReconnectCookie:
1511 if ((offset >= max) || !settings->ClientAutoReconnectCookie)
1513 return &settings->ClientAutoReconnectCookie[offset];
1514 case FreeRDP_ServerAutoReconnectCookie:
1516 if ((offset >= max) || !settings->ServerAutoReconnectCookie)
1518 return &settings->ServerAutoReconnectCookie[offset];
1519 case FreeRDP_ServerCertificate:
1523 return &settings->ServerCertificate[offset];
1524 case FreeRDP_ServerRandom:
1528 return &settings->ServerRandom[offset];
1529 case FreeRDP_ClientRandom:
1533 return &settings->ClientRandom[offset];
1534 case FreeRDP_LoadBalanceInfo:
1538 return &settings->LoadBalanceInfo[offset];
1540 case FreeRDP_RedirectionTsvUrl:
1544 return &settings->RedirectionTsvUrl[offset];
1546 case FreeRDP_RedirectionPassword:
1550 return &settings->RedirectionPassword[offset];
1552 case FreeRDP_OrderSupport:
1556 return &settings->OrderSupport[offset];
1557 case FreeRDP_MonitorIds:
1561 return &settings->MonitorIds[offset];
1562 case FreeRDP_MonitorDefArray:
1566 return &settings->MonitorDefArray[offset];
1567 case FreeRDP_ChannelDefArray:
1571 return &settings->ChannelDefArray[offset];
1572 case FreeRDP_DeviceArray:
1576 return settings->DeviceArray[offset];
1577 case FreeRDP_StaticChannelArray:
1581 return settings->StaticChannelArray[offset];
1582 case FreeRDP_DynamicChannelArray:
1586 return settings->DynamicChannelArray[offset];
1587 case FreeRDP_FragCache:
1591 return &settings->FragCache[offset];
1592 case FreeRDP_GlyphCache:
1596 return &settings->GlyphCache[offset];
1597 case FreeRDP_BitmapCacheV2CellInfo:
1601 return &settings->BitmapCacheV2CellInfo[offset];
1602 case FreeRDP_ReceivedCapabilities:
1606 return &settings->ReceivedCapabilities[offset];
1607 case FreeRDP_TargetNetAddresses:
1611 return settings->TargetNetAddresses[offset];
1612 case FreeRDP_TargetNetPorts:
1616 return &settings->TargetNetPorts[offset];
1617 case FreeRDP_ClientTimeZone:
1621 return settings->ClientTimeZone;
1622 case FreeRDP_RdpServerCertificate:
1626 return settings->RdpServerCertificate;
1627 case FreeRDP_RdpServerRsaKey:
1631 return settings->RdpServerRsaKey;
1638 WLog_WARN(TAG,
"Invalid offset for %s [%" PRIuz
"]: size=%" PRIuz
", offset=%" PRIuz,
1643 BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer
id,
1644 size_t offset,
const void* data)
1646 size_t maxOffset = 0;
1651 case FreeRDP_ClientAutoReconnectCookie:
1653 if ((offset >= maxOffset) || !data || !settings->ClientAutoReconnectCookie)
1657 case FreeRDP_ServerAutoReconnectCookie:
1659 if ((offset >= maxOffset) || !data || !settings->ServerAutoReconnectCookie)
1663 case FreeRDP_ServerCertificate:
1665 if ((offset >= maxOffset) || !data)
1667 settings->ServerCertificate[offset] = *(
const BYTE*)data;
1669 case FreeRDP_DeviceArray:
1671 if (offset >= maxOffset)
1673 freerdp_device_free(settings->DeviceArray[offset]);
1674 settings->DeviceArray[offset] = freerdp_device_clone(data);
1676 case FreeRDP_TargetNetAddresses:
1678 if ((offset >= maxOffset) || !data)
1680 free(settings->TargetNetAddresses[offset]);
1681 settings->TargetNetAddresses[offset] = _strdup((
const char*)data);
1682 return settings->TargetNetAddresses[offset] != NULL;
1683 case FreeRDP_TargetNetPorts:
1685 if ((offset >= maxOffset) || !data)
1687 settings->TargetNetPorts[offset] = *((
const UINT32*)data);
1689 case FreeRDP_StaticChannelArray:
1691 if ((offset >= maxOffset) || !data)
1693 freerdp_addin_argv_free(settings->StaticChannelArray[offset]);
1694 settings->StaticChannelArray[offset] = freerdp_addin_argv_clone(data);
1696 case FreeRDP_DynamicChannelArray:
1698 if ((offset >= maxOffset) || !data)
1700 freerdp_addin_argv_free(settings->DynamicChannelArray[offset]);
1701 settings->DynamicChannelArray[offset] = freerdp_addin_argv_clone(data);
1703 case FreeRDP_BitmapCacheV2CellInfo:
1705 if ((offset >= maxOffset) || !data)
1709 settings->BitmapCacheV2CellInfo[offset] = *cdata;
1712 case FreeRDP_ServerRandom:
1714 if ((offset >= maxOffset) || !data)
1716 settings->ServerRandom[offset] = *(
const BYTE*)data;
1718 case FreeRDP_ClientRandom:
1720 if ((offset >= maxOffset) || !data)
1722 settings->ClientRandom[offset] = *(
const BYTE*)data;
1724 case FreeRDP_LoadBalanceInfo:
1726 if ((offset >= maxOffset) || !data)
1728 settings->LoadBalanceInfo[offset] = *(
const BYTE*)data;
1730 case FreeRDP_RedirectionTsvUrl:
1732 if ((offset >= maxOffset) || !data)
1734 settings->RedirectionTsvUrl[offset] = *(
const BYTE*)data;
1736 case FreeRDP_RedirectionPassword:
1738 if ((offset >= maxOffset) || !data)
1740 settings->RedirectionPassword[offset] = *(
const BYTE*)data;
1742 case FreeRDP_OrderSupport:
1744 if (!settings->OrderSupport)
1746 if ((offset >= maxOffset) || !data)
1748 settings->OrderSupport[offset] = *(
const BOOL*)data;
1750 case FreeRDP_GlyphCache:
1752 if (!settings->GlyphCache)
1754 if ((offset >= maxOffset) || !data)
1758 case FreeRDP_FragCache:
1760 if (!settings->FragCache)
1762 if ((offset >= maxOffset) || !data)
1766 case FreeRDP_MonitorIds:
1768 if ((offset >= maxOffset) || !data)
1770 settings->MonitorIds[offset] = *(
const UINT32*)data;
1772 case FreeRDP_ChannelDefArray:
1774 if ((offset >= maxOffset) || !data)
1776 settings->ChannelDefArray[offset] = *(
const CHANNEL_DEF*)data;
1778 case FreeRDP_MonitorDefArray:
1780 if ((offset >= maxOffset) || !data)
1782 settings->MonitorDefArray[offset] = *(
const rdpMonitor*)data;
1785 case FreeRDP_ClientTimeZone:
1787 if ((offset >= maxOffset) || !data || !settings->ClientTimeZone)
1798 WLog_WARN(TAG,
"[%s] Invalid offset=%" PRIuz
" [%" PRIuz
"] or NULL data=%p",
1803 const void* freerdp_settings_get_pointer_array(
const rdpSettings* settings,
1804 FreeRDP_Settings_Keys_Pointer
id,
size_t offset)
1806 return freerdp_settings_get_pointer_array_writable(settings,
id, offset);
1811 UINT32 flags = FREERDP_CODEC_ALL;
1812 if (settings->RemoteFxCodec == FALSE)
1814 flags &= ~FREERDP_CODEC_REMOTEFX;
1816 if (settings->NSCodec == FALSE)
1818 flags &= ~FREERDP_CODEC_NSCODEC;
1826 WINPR_ASSERT(settings);
1827 const char* hostname = settings->ServerHostname;
1829 if (settings->UserSpecifiedServerName)
1830 hostname = settings->UserSpecifiedServerName;
1835 #if defined(WITH_FREERDP_DEPRECATED)
1838 return freerdp_addin_argv_clone(channel);
1843 return freerdp_addin_argv_clone(channel);
1847 BOOL freerdp_target_net_addresses_copy(rdpSettings* settings,
char** addresses, UINT32 count)
1849 WINPR_ASSERT(settings);
1850 WINPR_ASSERT(addresses);
1852 if (!freerdp_target_net_adresses_reset(settings, count))
1855 for (UINT32 i = 0; i < settings->TargetNetAddressCount; i++)
1857 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i,
1860 freerdp_target_net_addresses_free(settings);
1870 if (!what && !expect)
1872 if (!what || !expect)
1875 if (what->Id != expect->Id)
1877 if (what->Type != expect->Type)
1879 if (what->Name && expect->Name)
1881 if (strcmp(what->Name, expect->Name) != 0)
1886 if (what->Name != expect->Name)
1892 case RDPDR_DTYP_PRINT:
1896 if (a->DriverName && b->DriverName)
1897 return strcmp(a->DriverName, b->DriverName) == 0;
1898 return a->DriverName == b->DriverName;
1901 case RDPDR_DTYP_SERIAL:
1906 if (a->Path && b->Path)
1908 if (strcmp(a->Path, b->Path) != 0)
1911 else if (a->Path != b->Path)
1914 if (a->Driver && b->Driver)
1916 if (strcmp(a->Driver, b->Driver) != 0)
1919 else if (a->Driver != b->Driver)
1921 if (a->Permissive && b->Permissive)
1922 return strcmp(a->Permissive, b->Permissive) == 0;
1923 return a->Permissive == b->Permissive;
1926 case RDPDR_DTYP_PARALLEL:
1930 if (a->Path && b->Path)
1931 return strcmp(a->Path, b->Path) == 0;
1932 return a->Path == b->Path;
1935 case RDPDR_DTYP_SMARTCARD:
1937 case RDPDR_DTYP_FILESYSTEM:
1941 if (a->automount != b->automount)
1943 if (a->Path && b->Path)
1944 return strcmp(a->Path, b->Path) == 0;
1945 return a->Path == b->Path;
1958 RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
1959 RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
1960 RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED |
1961 RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED;
1963 if (flags & RAIL_LEVEL_SUPPORTED)
1964 winpr_str_append(
"RAIL_LEVEL_SUPPORTED", buffer, length,
"|");
1965 if (flags & RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED)
1966 winpr_str_append(
"RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED", buffer, length,
"|");
1967 if (flags & RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED)
1968 winpr_str_append(
"RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED", buffer, length,
"|");
1969 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
1970 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
1971 if (flags & RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED)
1972 winpr_str_append(
"RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED", buffer, length,
"|");
1973 if (flags & RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED)
1974 winpr_str_append(
"RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED", buffer, length,
"|");
1975 if (flags & RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED)
1976 winpr_str_append(
"RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED", buffer, length,
"|");
1977 if (flags & RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED)
1978 winpr_str_append(
"RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED", buffer, length,
"|");
1979 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
1980 winpr_str_append(
"RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length,
"|");
1981 if ((flags & ~mask) != 0)
1983 char tbuffer[64] = { 0 };
1984 (void)_snprintf(tbuffer,
sizeof(tbuffer),
"RAIL_FLAG_UNKNOWN 0x%08" PRIx32, flags & mask);
1985 winpr_str_append(tbuffer, buffer, length,
"|");
1991 const BYTE** capsData,
const UINT32* capsSizes,
1992 UINT32 capsCount, BOOL serverReceivedCaps)
1994 WINPR_ASSERT(settings);
1995 WINPR_ASSERT(capsFlags || (capsCount == 0));
1996 WINPR_ASSERT(capsData || (capsCount == 0));
1997 WINPR_ASSERT(capsSizes || (capsCount == 0));
1998 WINPR_ASSERT(capsCount <= UINT16_MAX);
2000 for (UINT32 x = 0; x < capsCount; x++)
2005 wStream* sub = Stream_StaticConstInit(&buffer, capsData[x], capsSizes[x]);
2007 if (!rdp_read_capability_set(sub, (UINT16)x, settings, serverReceivedCaps))
2020 return "RDP_VERSION_4";
2021 case RDP_VERSION_5_PLUS:
2022 return "RDP_VERSION_5_PLUS";
2023 case RDP_VERSION_10_0:
2024 return "RDP_VERSION_10_0";
2025 case RDP_VERSION_10_1:
2026 return "RDP_VERSION_10_1";
2027 case RDP_VERSION_10_2:
2028 return "RDP_VERSION_10_2";
2029 case RDP_VERSION_10_3:
2030 return "RDP_VERSION_10_3";
2031 case RDP_VERSION_10_4:
2032 return "RDP_VERSION_10_4";
2033 case RDP_VERSION_10_5:
2034 return "RDP_VERSION_10_5";
2035 case RDP_VERSION_10_6:
2036 return "RDP_VERSION_10_6";
2037 case RDP_VERSION_10_7:
2038 return "RDP_VERSION_10_7";
2039 case RDP_VERSION_10_8:
2040 return "RDP_VERSION_10_8";
2041 case RDP_VERSION_10_9:
2042 return "RDP_VERSION_10_9";
2043 case RDP_VERSION_10_10:
2044 return "RDP_VERSION_10_10";
2045 case RDP_VERSION_10_11:
2046 return "RDP_VERSION_10_11";
2047 case RDP_VERSION_10_12:
2048 return "RDP_VERSION_10_12";
2050 return "RDP_VERSION_UNKNOWN";
2057 WINPR_ASSERT(settings);
2060 return freerdp_settings_set_string_copy_(settings,
id, NULL, 0, TRUE);
2064 char* str = ConvertWCharToUtf8Alloc(param, &len);
2065 if (!str && (len != 0))
2068 return freerdp_settings_set_string_(settings,
id, str, len);
2072 const WCHAR* param,
size_t length)
2076 WINPR_ASSERT(settings);
2079 return freerdp_settings_set_string_copy_(settings,
id, NULL, length, TRUE);
2081 char* str = ConvertWCharNToUtf8Alloc(param, length, &len);
2082 if (!str && (length != 0))
2086 const size_t wlen = _wcsnlen(param, length);
2091 return freerdp_settings_set_string_(settings,
id, str, len);
2095 FreeRDP_Settings_Keys_String
id,
size_t* pCharLen)
2102 return ConvertUtf8ToWCharAlloc(str, pCharLen);
2109 case RDPDR_DTYP_FILESYSTEM:
2110 return "RDPDR_DTYP_FILESYSTEM";
2111 case RDPDR_DTYP_PARALLEL:
2112 return "RDPDR_DTYP_PARALLEL";
2113 case RDPDR_DTYP_PRINT:
2114 return "RDPDR_DTYP_PRINT";
2115 case RDPDR_DTYP_SERIAL:
2116 return "RDPDR_DTYP_SERIAL";
2117 case RDPDR_DTYP_SMARTCARD:
2118 return "RDPDR_DTYP_SMARTCARD";
2120 return "RDPDR_DTYP_UNKNOWN";
2124 const char* freerdp_encryption_level_string(UINT32 EncryptionLevel)
2126 switch (EncryptionLevel)
2128 case ENCRYPTION_LEVEL_NONE:
2129 return "ENCRYPTION_LEVEL_NONE";
2130 case ENCRYPTION_LEVEL_LOW:
2131 return "ENCRYPTION_LEVEL_LOW";
2132 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
2133 return "ENCRYPTION_LEVEL_CLIENT_COMPATIBLE";
2134 case ENCRYPTION_LEVEL_HIGH:
2135 return "ENCRYPTION_LEVEL_HIGH";
2136 case ENCRYPTION_LEVEL_FIPS:
2137 return "ENCRYPTION_LEVEL_FIPS";
2139 return "ENCRYPTION_LEVEL_UNKNOWN";
2143 const char* freerdp_encryption_methods_string(UINT32 EncryptionMethods,
char* buffer,
size_t size)
2145 if (EncryptionMethods == ENCRYPTION_METHOD_NONE)
2147 winpr_str_append(
"ENCRYPTION_METHOD_NONE", buffer, size,
"|");
2151 if (EncryptionMethods & ENCRYPTION_METHOD_40BIT)
2153 winpr_str_append(
"ENCRYPTION_METHOD_40BIT", buffer, size,
"|");
2155 if (EncryptionMethods & ENCRYPTION_METHOD_128BIT)
2157 winpr_str_append(
"ENCRYPTION_METHOD_128BIT", buffer, size,
"|");
2159 if (EncryptionMethods & ENCRYPTION_METHOD_56BIT)
2161 winpr_str_append(
"ENCRYPTION_METHOD_56BIT", buffer, size,
"|");
2163 if (EncryptionMethods & ENCRYPTION_METHOD_FIPS)
2165 winpr_str_append(
"ENCRYPTION_METHOD_FIPS", buffer, size,
"|");
2173 const UINT32 invalid = mask & ~(RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
2174 RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT);
2176 if (mask & RNS_UD_32BPP_SUPPORT)
2177 winpr_str_append(
"RNS_UD_32BPP_SUPPORT", buffer, size,
"|");
2178 if (mask & RNS_UD_24BPP_SUPPORT)
2179 winpr_str_append(
"RNS_UD_24BPP_SUPPORT", buffer, size,
"|");
2180 if (mask & RNS_UD_16BPP_SUPPORT)
2181 winpr_str_append(
"RNS_UD_16BPP_SUPPORT", buffer, size,
"|");
2182 if (mask & RNS_UD_15BPP_SUPPORT)
2183 winpr_str_append(
"RNS_UD_15BPP_SUPPORT", buffer, size,
"|");
2187 char str[32] = { 0 };
2188 (void)_snprintf(str,
sizeof(str),
"RNS_UD_INVALID[0x%04" PRIx32
"]", invalid);
2189 winpr_str_append(str, buffer, size,
"|");
2191 char hex[32] = { 0 };
2192 (void)_snprintf(hex,
sizeof(hex),
"[0x%04" PRIx16
"]", mask);
2197 const char* separator,
const char* param)
2205 winpr_asprintf(&str, &len,
"%s", param);
2206 else if (!separator)
2207 winpr_asprintf(&str, &len,
"%s%s", old, param);
2209 winpr_asprintf(&str, &len,
"%s%s%s", old, separator, param);
2218 return settings != NULL;
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
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 void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer 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.
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.
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string 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_set_pointer_len(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data, size_t len)
Set a pointer to value data.
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 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_*.
const char * freerdp_settings_get_server_name(const rdpSettings *settings)
A helper function to return the correct server name.
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.
WCHAR * freerdp_settings_get_string_as_utf16(const rdpSettings *settings, FreeRDP_Settings_Keys_String id, size_t *pCharLen)
Return an allocated UTF16 string.
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.
UINT32 freerdp_settings_get_codecs_flags(const rdpSettings *settings)
helper function to get a mask of supported codec flags.
const char * freerdp_rdp_version_string(UINT32 version)
Returns a stringified representation of the RDP protocol version.
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 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.
FREERDP_API void * freerdp_settings_get_pointer_writable(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a mutable pointer settings value.
FREERDP_API const char * freerdp_settings_get_name_for_key(SSIZE_T key)
Returns the type name for a key.