FreeRDP
Loading...
Searching...
No Matches
common/settings.c
1
23#include <freerdp/config.h>
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <errno.h>
29#include <math.h>
30
31#include <winpr/crt.h>
32#include <winpr/assert.h>
33#include <winpr/cast.h>
34
35#include "../core/settings.h"
36#include "../core/capabilities.h"
37
38#include <freerdp/crypto/certificate.h>
39#include <freerdp/settings.h>
40#include <freerdp/freerdp.h>
41#include <freerdp/log.h>
42
43#define TAG FREERDP_TAG("common")
44
45BOOL freerdp_addin_argv_add_argument_ex(ADDIN_ARGV* args, const char* argument, size_t len)
46{
47 if (!args || !argument)
48 return FALSE;
49
50 if (len == 0)
51 len = strlen(argument);
52
53 char** new_argv = (char**)realloc(
54 (void*)args->argv, sizeof(char*) * (WINPR_ASSERTING_INT_CAST(uint32_t, args->argc) + 1));
55
56 if (!new_argv)
57 return FALSE;
58
59 args->argv = new_argv;
60
61 char* str = calloc(len + 1, sizeof(char));
62 if (!str)
63 return FALSE;
64 memcpy(str, argument, len);
65 args->argv[args->argc++] = str;
66 return TRUE;
67}
68
69BOOL freerdp_addin_argv_add_argument(ADDIN_ARGV* args, const char* argument)
70{
71 return freerdp_addin_argv_add_argument_ex(args, argument, 0);
72}
73
74BOOL freerdp_addin_argv_del_argument(ADDIN_ARGV* args, const char* argument)
75{
76 if (!args || !argument)
77 return FALSE;
78 for (int x = 0; x < args->argc; x++)
79 {
80 char* arg = args->argv[x];
81 if (strcmp(argument, arg) == 0)
82 {
83 free(arg);
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;
89 args->argc--;
90 return TRUE;
91 }
92 }
93 return FALSE;
94}
95
96int freerdp_addin_set_argument(ADDIN_ARGV* args, const char* argument)
97{
98 if (!args || !argument)
99 return -2;
100
101 for (int i = 0; i < args->argc; i++)
102 {
103 if (strcmp(args->argv[i], argument) == 0)
104 {
105 return 1;
106 }
107 }
108
109 if (!freerdp_addin_argv_add_argument(args, argument))
110 return -1;
111 return 0;
112}
113
114int freerdp_addin_replace_argument(ADDIN_ARGV* args, const char* previous, const char* argument)
115{
116 if (!args || !previous || !argument)
117 return -2;
118
119 for (int i = 0; i < args->argc; i++)
120 {
121 if (strcmp(args->argv[i], previous) == 0)
122 {
123 free(args->argv[i]);
124
125 if (!(args->argv[i] = _strdup(argument)))
126 return -1;
127
128 return 1;
129 }
130 }
131
132 if (!freerdp_addin_argv_add_argument(args, argument))
133 return -1;
134 return 0;
135}
136
137int freerdp_addin_set_argument_value(ADDIN_ARGV* args, const char* option, const char* value)
138{
139 BOOL rc = 0;
140 char* p = NULL;
141 char* str = NULL;
142 size_t length = 0;
143 if (!args || !option || !value)
144 return -2;
145 length = strlen(option) + strlen(value) + 1;
146 str = (char*)calloc(length + 1, sizeof(char));
147
148 if (!str)
149 return -1;
150
151 (void)sprintf_s(str, length + 1, "%s:%s", option, value);
152
153 for (int i = 0; i < args->argc; i++)
154 {
155 p = strchr(args->argv[i], ':');
156
157 if (p)
158 {
159 if (strncmp(args->argv[i], option,
160 WINPR_ASSERTING_INT_CAST(size_t, p - args->argv[i])) == 0)
161 {
162 free(args->argv[i]);
163 args->argv[i] = str;
164 return 1;
165 }
166 }
167 }
168
169 rc = freerdp_addin_argv_add_argument(args, str);
170 free(str);
171 if (!rc)
172 return -1;
173 return 0;
174}
175
176int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, const char* previous, const char* option,
177 const char* value)
178{
179 BOOL rc = 0;
180 char* str = NULL;
181 size_t length = 0;
182 if (!args || !previous || !option || !value)
183 return -2;
184 length = strlen(option) + strlen(value) + 1;
185 str = (char*)calloc(length + 1, sizeof(char));
186
187 if (!str)
188 return -1;
189
190 (void)sprintf_s(str, length + 1, "%s:%s", option, value);
191
192 for (int i = 0; i < args->argc; i++)
193 {
194 if (strcmp(args->argv[i], previous) == 0)
195 {
196 free(args->argv[i]);
197 args->argv[i] = str;
198 return 1;
199 }
200 }
201
202 rc = freerdp_addin_argv_add_argument(args, str);
203 free(str);
204 if (!rc)
205 return -1;
206 return 0;
207}
208
209BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device)
210{
211 UINT32 count = 0;
212 UINT32 old = 0;
213 WINPR_ASSERT(settings);
214 WINPR_ASSERT(device);
215
216 count = freerdp_settings_get_uint32(settings, FreeRDP_DeviceCount) + 1;
217 old = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
218 if (old < count)
219 {
220 const size_t new_size = (old + 32);
221 RDPDR_DEVICE** new_array =
222 (RDPDR_DEVICE**)realloc((void*)settings->DeviceArray, new_size * sizeof(RDPDR_DEVICE*));
223
224 if (!new_array)
225 return FALSE;
226
227 settings->DeviceArray = new_array;
228 for (size_t x = old; x < new_size; x++)
229 settings->DeviceArray[x] = NULL;
230
231 if (!freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize,
232 WINPR_ASSERTING_INT_CAST(uint32_t, new_size)))
233 return FALSE;
234 }
235
236 settings->DeviceArray[settings->DeviceCount++] = device;
237 return TRUE;
238}
239
240BOOL freerdp_device_collection_del(rdpSettings* settings, const RDPDR_DEVICE* device)
241{
242 WINPR_ASSERT(settings);
243
244 if (!device)
245 return FALSE;
246
247 const UINT32 count = settings->DeviceCount;
248 for (size_t x = 0; x < count; x++)
249 {
250 const RDPDR_DEVICE* cur = settings->DeviceArray[x];
251 if (cur == device)
252 {
253 for (size_t y = x + 1; y < count; y++)
254 {
255 RDPDR_DEVICE* next = settings->DeviceArray[y];
256 settings->DeviceArray[y - 1] = next;
257 }
258 settings->DeviceArray[count - 1] = NULL;
259 settings->DeviceCount--;
260 return TRUE;
261 }
262 }
263
264 return FALSE;
265}
266
267RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings, const char* name)
268{
269 RDPDR_DEVICE* device = NULL;
270
271 WINPR_ASSERT(settings);
272 WINPR_ASSERT(name);
273 for (UINT32 index = 0; index < settings->DeviceCount; index++)
274 {
275 device = settings->DeviceArray[index];
276
277 if (!device->Name)
278 continue;
279
280 if (strcmp(device->Name, name) == 0)
281 return device;
282 }
283
284 return NULL;
285}
286
287RDPDR_DEVICE* freerdp_device_collection_find_type(rdpSettings* settings, UINT32 type)
288{
289 RDPDR_DEVICE* device = NULL;
290 WINPR_ASSERT(settings);
291
292 for (UINT32 index = 0; index < settings->DeviceCount; index++)
293 {
294 device = settings->DeviceArray[index];
295
296 if (device->Type == type)
297 return device;
298 }
299
300 return NULL;
301}
302
303RDPDR_DEVICE* freerdp_device_new(UINT32 Type, size_t count, const char* const args[])
304{
305 size_t size = 0;
306 union
307 {
308 RDPDR_DEVICE* base;
309 RDPDR_DRIVE* drive;
310 RDPDR_SERIAL* serial;
311 RDPDR_PRINTER* printer;
312 RDPDR_PARALLEL* parallel;
313 RDPDR_SMARTCARD* smartcard;
314 } device;
315
316 device.base = NULL;
317 WINPR_ASSERT(args || (count == 0));
318
319 switch (Type)
320 {
321 case RDPDR_DTYP_PRINT:
322 size = sizeof(RDPDR_PRINTER);
323 break;
324 case RDPDR_DTYP_SERIAL:
325 size = sizeof(RDPDR_SERIAL);
326 break;
327 case RDPDR_DTYP_PARALLEL:
328 size = sizeof(RDPDR_PARALLEL);
329 break;
330 case RDPDR_DTYP_SMARTCARD:
331 size = sizeof(RDPDR_SMARTCARD);
332 break;
333 case RDPDR_DTYP_FILESYSTEM:
334 size = sizeof(RDPDR_DRIVE);
335 break;
336 default:
337 goto fail;
338 }
339
340 device.base = calloc(1, size);
341 if (!device.base)
342 goto fail;
343 device.base->Id = 0;
344 device.base->Type = Type;
345
346 if (count > 0)
347 {
348 device.base->Name = _strdup(args[0]);
349 if (!device.base->Name)
350 goto fail;
351
352 switch (Type)
353 {
354 case RDPDR_DTYP_PRINT:
355 if (count > 1)
356 {
357 device.printer->DriverName = _strdup(args[1]);
358 if (!device.printer->DriverName)
359 goto fail;
360 }
361
362 if (count > 2)
363 {
364 device.printer->IsDefault = _stricmp(args[2], "default") == 0;
365 }
366 break;
367 case RDPDR_DTYP_SERIAL:
368 if (count > 1)
369 {
370 device.serial->Path = _strdup(args[1]);
371 if (!device.serial->Path)
372 goto fail;
373 }
374
375 if (count > 2)
376 {
377 device.serial->Driver = _strdup(args[2]);
378 if (!device.serial->Driver)
379 goto fail;
380 }
381
382 if (count > 3)
383 {
384 device.serial->Permissive = _strdup(args[3]);
385 if (!device.serial->Permissive)
386 goto fail;
387 }
388 break;
389 case RDPDR_DTYP_PARALLEL:
390 if (count > 1)
391 {
392 device.parallel->Path = _strdup(args[1]);
393 if (!device.serial->Path)
394 goto fail;
395 }
396 break;
397 case RDPDR_DTYP_SMARTCARD:
398 break;
399 case RDPDR_DTYP_FILESYSTEM:
400 if (count > 1)
401 {
402 device.drive->Path = _strdup(args[1]);
403 if (!device.drive->Path)
404 goto fail;
405 }
406 if (count > 2)
407 device.drive->automount = (args[2] == NULL) ? TRUE : FALSE;
408 break;
409 default:
410 goto fail;
411 }
412 }
413 return device.base;
414
415fail:
416 freerdp_device_free(device.base);
417 return NULL;
418}
419
420void freerdp_device_free(RDPDR_DEVICE* device)
421{
422 if (!device)
423 return;
424
425 union
426 {
427 RDPDR_DEVICE* dev;
428 RDPDR_DRIVE* drive;
429 RDPDR_SERIAL* serial;
430 RDPDR_PRINTER* printer;
431 RDPDR_PARALLEL* parallel;
432 RDPDR_SMARTCARD* smartcard;
433 } cnv;
434
435 cnv.dev = device;
436
437 switch (device->Type)
438 {
439 case RDPDR_DTYP_PRINT:
440 free(cnv.printer->DriverName);
441 break;
442 case RDPDR_DTYP_SERIAL:
443 free(cnv.serial->Path);
444 free(cnv.serial->Driver);
445 free(cnv.serial->Permissive);
446 break;
447 case RDPDR_DTYP_PARALLEL:
448 free(cnv.parallel->Path);
449 break;
450 case RDPDR_DTYP_SMARTCARD:
451 break;
452 case RDPDR_DTYP_FILESYSTEM:
453 free(cnv.drive->Path);
454 break;
455 default:
456 break;
457 }
458 free(cnv.dev->Name);
459 free(cnv.dev);
460}
461
462RDPDR_DEVICE* freerdp_device_clone(const RDPDR_DEVICE* device)
463{
464 union
465 {
466 const RDPDR_DEVICE* dev;
467 const RDPDR_DRIVE* drive;
468 const RDPDR_SERIAL* serial;
469 const RDPDR_PRINTER* printer;
470 const RDPDR_PARALLEL* parallel;
471 const RDPDR_SMARTCARD* smartcard;
472 } src;
473
474 union
475 {
476 RDPDR_DEVICE* dev;
477 RDPDR_DRIVE* drive;
478 RDPDR_SERIAL* serial;
479 RDPDR_PRINTER* printer;
480 RDPDR_PARALLEL* parallel;
481 RDPDR_SMARTCARD* smartcard;
482 } copy;
483 size_t count = 0;
484 const char* args[4] = { 0 };
485
486 copy.dev = NULL;
487 src.dev = device;
488
489 if (!device)
490 return NULL;
491
492 if (device->Name)
493 {
494 args[count++] = device->Name;
495 }
496
497 switch (device->Type)
498 {
499 case RDPDR_DTYP_FILESYSTEM:
500 if (src.drive->Path)
501 {
502 args[count++] = src.drive->Path;
503 args[count++] = src.drive->automount ? NULL : src.drive->Path;
504 }
505 break;
506
507 case RDPDR_DTYP_PRINT:
508 if (src.printer->DriverName)
509 args[count++] = src.printer->DriverName;
510 break;
511
512 case RDPDR_DTYP_SMARTCARD:
513 break;
514
515 case RDPDR_DTYP_SERIAL:
516 if (src.serial->Path)
517 args[count++] = src.serial->Path;
518
519 if (src.serial->Driver)
520 args[count++] = src.serial->Driver;
521
522 if (src.serial->Permissive)
523 args[count++] = src.serial->Permissive;
524 break;
525
526 case RDPDR_DTYP_PARALLEL:
527 if (src.parallel->Path)
528 args[count++] = src.parallel->Path;
529 break;
530 default:
531 WLog_ERR(TAG, "unknown device type %" PRIu32 "", device->Type);
532 break;
533 }
534
535 copy.dev = freerdp_device_new(device->Type, count, args);
536 if (!copy.dev)
537 return NULL;
538
539 copy.dev->Id = device->Id;
540
541 return copy.dev;
542}
543
544void freerdp_device_collection_free(rdpSettings* settings)
545{
546 WINPR_ASSERT(settings);
547
548 if (settings->DeviceArray)
549 {
550 for (UINT32 index = 0; index < settings->DeviceArraySize; index++)
551 (void)freerdp_settings_set_pointer_array(settings, FreeRDP_DeviceArray, index, NULL);
552 }
553
554 free((void*)settings->DeviceArray);
555
556 (void)freerdp_settings_set_pointer(settings, FreeRDP_DeviceArray, NULL);
557 (void)freerdp_settings_set_uint32(settings, FreeRDP_DeviceArraySize, 0);
558 (void)freerdp_settings_set_uint32(settings, FreeRDP_DeviceCount, 0);
559}
560
561BOOL freerdp_static_channel_collection_del(rdpSettings* settings, const char* name)
562{
563 const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
564 if (!settings || !settings->StaticChannelArray)
565 return FALSE;
566
567 for (UINT32 x = 0; x < count; x++)
568 {
569 ADDIN_ARGV* cur = settings->StaticChannelArray[x];
570 if (cur && (cur->argc > 0))
571 {
572 if (strcmp(name, cur->argv[0]) == 0)
573 {
574 memmove_s((void*)&settings->StaticChannelArray[x],
575 (count - x) * sizeof(ADDIN_ARGV*),
576 (void*)&settings->StaticChannelArray[x + 1],
577 (count - x - 1) * sizeof(ADDIN_ARGV*));
578 for (size_t y = count - 1; y < settings->StaticChannelArraySize; y++)
579 settings->StaticChannelArray[y] = NULL;
580
581 freerdp_addin_argv_free(cur);
582 return freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, count - 1);
583 }
584 }
585 }
586 {
587 for (size_t x = count; x < settings->StaticChannelArraySize; x++)
588 settings->StaticChannelArray[x] = NULL;
589 }
590 return FALSE;
591}
592
593BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
594{
595 UINT32 count = 0;
596
597 WINPR_ASSERT(settings);
598 WINPR_ASSERT(channel);
599
600 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount) + 1;
601 if (freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize) < count)
602 {
603 const UINT32 oldSize =
604 freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
605 const size_t new_size = oldSize + 32ul;
606 ADDIN_ARGV** new_array = (ADDIN_ARGV**)realloc((void*)settings->StaticChannelArray,
607 new_size * sizeof(ADDIN_ARGV*));
608
609 if (!new_array)
610 return FALSE;
611
612 settings->StaticChannelArray = new_array;
613 {
614 for (size_t x = oldSize; x < new_size; x++)
615 settings->StaticChannelArray[x] = NULL;
616 }
617 if (!freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize,
618 WINPR_ASSERTING_INT_CAST(uint32_t, new_size)))
619 return FALSE;
620 }
621
622 count = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount);
623
624 ADDIN_ARGV** cur = &settings->StaticChannelArray[count++];
625 freerdp_addin_argv_free(*cur);
626 *cur = channel;
627 return freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, count);
628}
629
630ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const char* name)
631{
632 ADDIN_ARGV* channel = NULL;
633
634 WINPR_ASSERT(settings);
635 WINPR_ASSERT(name);
636
637 for (UINT32 index = 0;
638 index < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelCount); index++)
639 {
640 channel = settings->StaticChannelArray[index];
641
642 if (strcmp(channel->argv[0], name) == 0)
643 return channel;
644 }
645
646 return NULL;
647}
648
649void freerdp_static_channel_collection_free(rdpSettings* settings)
650{
651 if (!settings)
652 return;
653
654 if (settings->StaticChannelArray)
655 {
656 for (UINT32 i = 0;
657 i < freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize); i++)
658 freerdp_addin_argv_free(settings->StaticChannelArray[i]);
659 }
660
661 free((void*)settings->StaticChannelArray);
662 (void)freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelArraySize, 0);
663 settings->StaticChannelArray = NULL;
664 (void)freerdp_settings_set_uint32(settings, FreeRDP_StaticChannelCount, 0);
665}
666
667BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings, const char* name)
668{
669 const UINT32 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
670 if (!settings || !settings->DynamicChannelArray)
671 return FALSE;
672
673 for (UINT32 x = 0; x < count; x++)
674 {
675 ADDIN_ARGV* cur = settings->DynamicChannelArray[x];
676 if (cur && (cur->argc > 0))
677 {
678 if (strcmp(name, cur->argv[0]) == 0)
679 {
680 memmove_s((void*)&settings->DynamicChannelArray[x],
681 (count - x) * sizeof(ADDIN_ARGV*),
682 (void*)&settings->DynamicChannelArray[x + 1],
683 (count - x - 1) * sizeof(ADDIN_ARGV*));
684 for (size_t y = count - 1; y < settings->DynamicChannelArraySize; y++)
685 settings->DynamicChannelArray[y] = NULL;
686
687 freerdp_addin_argv_free(cur);
688 return freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount,
689 count - 1);
690 }
691 }
692 }
693
694 return FALSE;
695}
696
697BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
698{
699 UINT32 count = 0;
700 UINT32 oldSize = 0;
701
702 WINPR_ASSERT(settings);
703 WINPR_ASSERT(channel);
704
705 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount) + 1;
706 oldSize = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
707 if (oldSize < count)
708 {
709
710 const size_t size = oldSize + 32;
711 ADDIN_ARGV** new_array =
712 (ADDIN_ARGV**)realloc((void*)settings->DynamicChannelArray, sizeof(ADDIN_ARGV*) * size);
713
714 if (!new_array)
715 return FALSE;
716
717 settings->DynamicChannelArray = new_array;
718 {
719 for (size_t x = oldSize; x < size; x++)
720 settings->DynamicChannelArray[x] = NULL;
721 }
722 if (!freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize,
723 WINPR_ASSERTING_INT_CAST(uint32_t, size)))
724 return FALSE;
725 }
726
727 count = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount);
728 settings->DynamicChannelArray[count++] = channel;
729 return freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, count);
730}
731
732ADDIN_ARGV* freerdp_dynamic_channel_collection_find(const rdpSettings* settings, const char* name)
733{
734 WINPR_ASSERT(settings);
735 WINPR_ASSERT(name);
736
737 for (UINT32 index = 0;
738 index < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelCount); index++)
739 {
740 ADDIN_ARGV* channel = settings->DynamicChannelArray[index];
741
742 if (strcmp(channel->argv[0], name) == 0)
743 return channel;
744 }
745
746 return NULL;
747}
748
749void freerdp_addin_argv_free(ADDIN_ARGV* args)
750{
751 if (!args)
752 return;
753
754 if (args->argv)
755 {
756 for (int index = 0; index < args->argc; index++)
757 free(args->argv[index]);
758 free((void*)args->argv);
759 }
760
761 free(args);
762}
763
764ADDIN_ARGV* freerdp_addin_argv_new(size_t argc, const char* const argv[])
765{
766 if (argc > INT32_MAX)
767 return NULL;
768
769 ADDIN_ARGV* args = calloc(1, sizeof(ADDIN_ARGV));
770 if (!args)
771 return NULL;
772 if (argc == 0)
773 return args;
774
775 args->argc = (int)argc;
776 args->argv = (char**)calloc(argc, sizeof(char*));
777 if (!args->argv)
778 goto fail;
779
780 if (argv)
781 {
782 for (size_t x = 0; x < argc; x++)
783 {
784 args->argv[x] = _strdup(argv[x]);
785 if (!args->argv[x])
786 goto fail;
787 }
788 }
789 return args;
790
791fail:
792 WINPR_PRAGMA_DIAG_PUSH
793 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
794 freerdp_addin_argv_free(args);
795 WINPR_PRAGMA_DIAG_POP
796 return NULL;
797}
798
799ADDIN_ARGV* freerdp_addin_argv_clone(const ADDIN_ARGV* args)
800{
801 union
802 {
803 char** c;
804 const char** cc;
805 } cnv;
806 if (!args)
807 return NULL;
808 cnv.c = args->argv;
809 return freerdp_addin_argv_new(WINPR_ASSERTING_INT_CAST(uint32_t, args->argc), cnv.cc);
810}
811
812void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
813{
814 WINPR_ASSERT(settings);
815
816 if (settings->DynamicChannelArray)
817 {
818 for (UINT32 i = 0;
819 i < freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize); i++)
820 freerdp_addin_argv_free(settings->DynamicChannelArray[i]);
821 }
822
823 free((void*)settings->DynamicChannelArray);
824 (void)freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelArraySize, 0);
825 settings->DynamicChannelArray = NULL;
826 (void)freerdp_settings_set_uint32(settings, FreeRDP_DynamicChannelCount, 0);
827}
828
829static void freerdp_capability_data_free(rdpSettings* settings, size_t offset, BOOL full)
830{
831 WINPR_ASSERT(settings);
832
833 if (settings->ReceivedCapabilityData)
834 {
835 for (size_t x = offset; x < settings->ReceivedCapabilitiesSize; x++)
836 {
837 free(settings->ReceivedCapabilityData[x]);
838 settings->ReceivedCapabilityData[x] = NULL;
839 }
840 if (full)
841 {
842 free((void*)settings->ReceivedCapabilityData);
843 settings->ReceivedCapabilityData = NULL;
844 }
845 }
846}
847
848void freerdp_capability_buffer_free(rdpSettings* settings)
849{
850 WINPR_ASSERT(settings);
851
852 freerdp_capability_data_free(settings, 0, TRUE);
853
854 free(settings->ReceivedCapabilityDataSizes);
855 settings->ReceivedCapabilityDataSizes = NULL;
856
857 free(settings->ReceivedCapabilities);
858 settings->ReceivedCapabilities = NULL;
859
860 settings->ReceivedCapabilitiesSize = 0;
861}
862
863static BOOL resize_setting(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id, size_t oldsize,
864 size_t size, size_t base)
865{
866 void* old = freerdp_settings_get_pointer_writable(settings, id);
867 uint8_t* ptr = realloc(old, size * base);
868 if (!ptr)
869 return FALSE;
870
871 if (size > oldsize)
872 {
873 const size_t diff = size - oldsize;
874 memset(&ptr[oldsize * base], 0, diff * base);
875 }
876
877 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc
878 return freerdp_settings_set_pointer(settings, id, ptr);
879}
880
881BOOL freerdp_capability_buffer_resize(rdpSettings* settings, size_t count)
882{
883 WINPR_ASSERT(settings);
884
885 const uint32_t len = settings->ReceivedCapabilitiesSize;
886 if (len == count)
887 return TRUE;
888
889 freerdp_capability_data_free(settings, count, FALSE);
890
891 if (count == 0)
892 {
893 freerdp_capability_buffer_free(settings);
894 return TRUE;
895 }
896
897 const size_t oldsize = settings->ReceivedCapabilitiesSize;
898 if (!resize_setting(settings, FreeRDP_ReceivedCapabilityDataSizes, oldsize, count,
899 sizeof(uint32_t)))
900 return FALSE;
901 if (!resize_setting(settings, FreeRDP_ReceivedCapabilityData, oldsize, count, sizeof(uint8_t*)))
902 return FALSE;
903 if (!resize_setting(settings, FreeRDP_ReceivedCapabilities, oldsize, count, sizeof(uint32_t)))
904 return FALSE;
905
906 settings->ReceivedCapabilitiesSize = WINPR_ASSERTING_INT_CAST(uint32_t, count);
907 return TRUE;
908}
909
910BOOL freerdp_capability_buffer_copy(rdpSettings* settings, const rdpSettings* src)
911{
912 WINPR_ASSERT(settings);
913 WINPR_ASSERT(src);
914
915 if (src->ReceivedCapabilitiesSize == 0)
916 return TRUE;
917
918 if (!freerdp_capability_buffer_resize(settings, src->ReceivedCapabilitiesSize))
919 return FALSE;
920
921 for (UINT32 x = 0; x < src->ReceivedCapabilitiesSize; x++)
922 {
923 WINPR_ASSERT(settings->ReceivedCapabilities);
924 settings->ReceivedCapabilities[x] = src->ReceivedCapabilities[x];
925
926 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
927 settings->ReceivedCapabilityDataSizes[x] = src->ReceivedCapabilityDataSizes[x];
928
929 WINPR_ASSERT(settings->ReceivedCapabilityData);
930 if (src->ReceivedCapabilityDataSizes[x] > 0)
931 {
932 void* tmp = realloc(settings->ReceivedCapabilityData[x],
933 settings->ReceivedCapabilityDataSizes[x]);
934 if (!tmp)
935 return FALSE;
936 memcpy(tmp, src->ReceivedCapabilityData[x], src->ReceivedCapabilityDataSizes[x]);
937 settings->ReceivedCapabilityData[x] = tmp;
938 }
939 else
940 {
941 free(settings->ReceivedCapabilityData[x]);
942 settings->ReceivedCapabilityData[x] = NULL;
943 }
944 }
945 return TRUE;
946}
947
948static void target_net_addresses_free(rdpSettings* settings, size_t offset)
949{
950 WINPR_ASSERT(settings);
951
952 if (settings->TargetNetAddresses)
953 {
954 for (size_t index = offset; index < settings->TargetNetAddressCount; index++)
955 {
956 free(settings->TargetNetAddresses[index]);
957 settings->TargetNetAddresses[index] = NULL;
958 }
959 }
960}
961
962void freerdp_target_net_addresses_free(rdpSettings* settings)
963{
964 WINPR_ASSERT(settings);
965
966 target_net_addresses_free(settings, 0);
967
968 free((void*)settings->TargetNetAddresses);
969 settings->TargetNetAddresses = NULL;
970
971 free(settings->TargetNetPorts);
972 settings->TargetNetPorts = NULL;
973
974 settings->TargetNetAddressCount = 0;
975}
976
977BOOL freerdp_target_net_addresses_resize(rdpSettings* settings, size_t count)
978{
979 WINPR_ASSERT(settings);
980
981 if (count == 0)
982 {
983 freerdp_target_net_addresses_free(settings);
984 return TRUE;
985 }
986
987 const uint32_t len = settings->TargetNetAddressCount;
988 size_t offset = 0;
989 if (len > count)
990 offset = count;
991
992 target_net_addresses_free(settings, offset);
993
994 if (!resize_setting(settings, FreeRDP_TargetNetAddresses, len, count, sizeof(char*)))
995 return FALSE;
996 if (!resize_setting(settings, FreeRDP_TargetNetPorts, len, count, sizeof(uint32_t)))
997 return FALSE;
998
999 settings->TargetNetAddressCount = WINPR_ASSERTING_INT_CAST(uint32_t, count);
1000 return TRUE;
1001}
1002
1003void freerdp_server_license_issuers_free(rdpSettings* settings)
1004{
1005 WINPR_ASSERT(settings);
1006
1007 if (settings->ServerLicenseProductIssuers)
1008 {
1009 for (UINT32 x = 0; x < settings->ServerLicenseProductIssuersCount; x++)
1010 free(settings->ServerLicenseProductIssuers[x]);
1011 }
1012 free((void*)settings->ServerLicenseProductIssuers);
1013 settings->ServerLicenseProductIssuers = NULL;
1014 settings->ServerLicenseProductIssuersCount = 0;
1015}
1016
1017BOOL freerdp_server_license_issuers_copy(rdpSettings* settings, char** issuers, UINT32 count)
1018{
1019 WINPR_ASSERT(settings);
1020 WINPR_ASSERT(issuers || (count == 0));
1021
1022 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ServerLicenseProductIssuers, NULL,
1023 count))
1024 return FALSE;
1025
1026 for (UINT32 x = 0; x < count; x++)
1027 {
1028 char* issuer = _strdup(issuers[x]);
1029 if (!issuer)
1030 return FALSE;
1031 settings->ServerLicenseProductIssuers[x] = issuer;
1032 }
1033
1034 return TRUE;
1035}
1036
1037void freerdp_performance_flags_make(rdpSettings* settings)
1038{
1039 UINT32 PerformanceFlags = PERF_FLAG_NONE;
1040
1041 if (freerdp_settings_get_bool(settings, FreeRDP_AllowFontSmoothing))
1042 PerformanceFlags |= PERF_ENABLE_FONT_SMOOTHING;
1043
1044 if (freerdp_settings_get_bool(settings, FreeRDP_AllowDesktopComposition))
1045 PerformanceFlags |= PERF_ENABLE_DESKTOP_COMPOSITION;
1046
1047 if (freerdp_settings_get_bool(settings, FreeRDP_DisableWallpaper))
1048 PerformanceFlags |= PERF_DISABLE_WALLPAPER;
1049
1050 if (freerdp_settings_get_bool(settings, FreeRDP_DisableFullWindowDrag))
1051 PerformanceFlags |= PERF_DISABLE_FULLWINDOWDRAG;
1052
1053 if (freerdp_settings_get_bool(settings, FreeRDP_DisableMenuAnims))
1054 PerformanceFlags |= PERF_DISABLE_MENUANIMATIONS;
1055
1056 if (freerdp_settings_get_bool(settings, FreeRDP_DisableThemes))
1057 PerformanceFlags |= PERF_DISABLE_THEMING;
1058 (void)freerdp_settings_set_uint32(settings, FreeRDP_PerformanceFlags, PerformanceFlags);
1059}
1060
1061void freerdp_performance_flags_split(rdpSettings* settings)
1062{
1063 (void)freerdp_settings_set_bool(
1064 settings, FreeRDP_AllowFontSmoothing,
1065 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
1066 PERF_ENABLE_FONT_SMOOTHING)
1067 ? TRUE
1068 : FALSE);
1069 (void)freerdp_settings_set_bool(
1070 settings, FreeRDP_AllowDesktopComposition,
1071 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
1072 PERF_ENABLE_DESKTOP_COMPOSITION)
1073 ? TRUE
1074 : FALSE);
1075 (void)freerdp_settings_set_bool(
1076 settings, FreeRDP_DisableWallpaper,
1077 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_WALLPAPER)
1078 ? TRUE
1079 : FALSE);
1080 (void)freerdp_settings_set_bool(
1081 settings, FreeRDP_DisableFullWindowDrag,
1082 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
1083 PERF_DISABLE_FULLWINDOWDRAG)
1084 ? TRUE
1085 : FALSE);
1086 (void)freerdp_settings_set_bool(
1087 settings, FreeRDP_DisableMenuAnims,
1088 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) &
1089 PERF_DISABLE_MENUANIMATIONS)
1090 ? TRUE
1091 : FALSE);
1092 (void)freerdp_settings_set_bool(
1093 settings, FreeRDP_DisableThemes,
1094 (freerdp_settings_get_uint32(settings, FreeRDP_PerformanceFlags) & PERF_DISABLE_THEMING)
1095 ? TRUE
1096 : FALSE);
1097}
1098
1099BOOL freerdp_set_gateway_usage_method(rdpSettings* settings, UINT32 GatewayUsageMethod)
1100{
1101 if (!freerdp_settings_set_uint32(settings, FreeRDP_GatewayUsageMethod, GatewayUsageMethod))
1102 return FALSE;
1103
1104 if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DIRECT)
1105 {
1106 if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
1107 !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
1108 return FALSE;
1109 }
1110 else if (GatewayUsageMethod == TSC_PROXY_MODE_DIRECT)
1111 {
1112 if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, TRUE) ||
1113 !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
1114 return FALSE;
1115 }
1116 else if (GatewayUsageMethod == TSC_PROXY_MODE_DETECT)
1117 {
1118 if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, TRUE) ||
1119 !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, TRUE))
1120 return FALSE;
1121 }
1122 else if (GatewayUsageMethod == TSC_PROXY_MODE_DEFAULT)
1123 {
1129 if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
1130 !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
1131 return FALSE;
1132 }
1133 else if (GatewayUsageMethod == TSC_PROXY_MODE_NONE_DETECT)
1134 {
1135 if (!freerdp_settings_set_bool(settings, FreeRDP_GatewayEnabled, FALSE) ||
1136 !freerdp_settings_set_bool(settings, FreeRDP_GatewayBypassLocal, FALSE))
1137 return FALSE;
1138 }
1139
1140 return TRUE;
1141}
1142
1143void freerdp_update_gateway_usage_method(rdpSettings* settings, UINT32 GatewayEnabled,
1144 UINT32 GatewayBypassLocal)
1145{
1146 UINT32 GatewayUsageMethod = 0;
1147
1148 if (!GatewayEnabled && !GatewayBypassLocal)
1149 GatewayUsageMethod = TSC_PROXY_MODE_NONE_DIRECT;
1150 else if (GatewayEnabled && !GatewayBypassLocal)
1151 GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
1152 else if (GatewayEnabled && GatewayBypassLocal)
1153 GatewayUsageMethod = TSC_PROXY_MODE_DETECT;
1154
1155 freerdp_set_gateway_usage_method(settings, GatewayUsageMethod);
1156}
1157
1158#if defined(WITH_FREERDP_DEPRECATED)
1159BOOL freerdp_get_param_bool(const rdpSettings* settings, int id)
1160{
1161 return freerdp_settings_get_bool(settings, (FreeRDP_Settings_Keys_Bool)id);
1162}
1163
1164int freerdp_set_param_bool(rdpSettings* settings, int id, BOOL param)
1165{
1166 return freerdp_settings_set_bool(settings, (FreeRDP_Settings_Keys_Bool)id, param) ? 0 : -1;
1167}
1168
1169int freerdp_get_param_int(const rdpSettings* settings, int id)
1170{
1171 return freerdp_settings_get_int32(settings, (FreeRDP_Settings_Keys_Int32)id);
1172}
1173
1174int freerdp_set_param_int(rdpSettings* settings, int id, int param)
1175{
1176 return freerdp_settings_set_int32(settings, (FreeRDP_Settings_Keys_Int32)id, param) ? 0 : -1;
1177}
1178
1179UINT32 freerdp_get_param_uint32(const rdpSettings* settings, int id)
1180{
1181 return freerdp_settings_get_uint32(settings, (FreeRDP_Settings_Keys_UInt32)id);
1182}
1183
1184int freerdp_set_param_uint32(rdpSettings* settings, int id, UINT32 param)
1185{
1186 return freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)id, param) ? 0 : -1;
1187}
1188
1189UINT64 freerdp_get_param_uint64(const rdpSettings* settings, int id)
1190{
1191 return freerdp_settings_get_uint64(settings, (FreeRDP_Settings_Keys_UInt64)id);
1192}
1193
1194int freerdp_set_param_uint64(rdpSettings* settings, int id, UINT64 param)
1195{
1196 return freerdp_settings_set_uint64(settings, (FreeRDP_Settings_Keys_UInt64)id, param) ? 0 : -1;
1197}
1198
1199char* freerdp_get_param_string(const rdpSettings* settings, int id)
1200{
1201 const char* str = freerdp_settings_get_string(settings, (FreeRDP_Settings_Keys_String)id);
1202 return WINPR_CAST_CONST_PTR_AWAY(str, char*);
1203}
1204
1205int freerdp_set_param_string(rdpSettings* settings, int id, const char* param)
1206{
1207 return freerdp_settings_set_string(settings, (FreeRDP_Settings_Keys_String)id, param) ? 0 : -1;
1208}
1209#endif
1210
1211static BOOL value_to_uint(const char* value, ULONGLONG* result, ULONGLONG min, ULONGLONG max)
1212{
1213 char* endptr = NULL;
1214 unsigned long long rc = 0;
1215
1216 if (!value || !result)
1217 return FALSE;
1218
1219 errno = 0;
1220 rc = _strtoui64(value, &endptr, 0);
1221
1222 if (errno != 0)
1223 return FALSE;
1224
1225 if (endptr == value)
1226 return FALSE;
1227
1228 if ((rc < min) || (rc > max))
1229 return FALSE;
1230
1231 *result = rc;
1232 return TRUE;
1233}
1234
1235static BOOL value_to_int(const char* value, LONGLONG* result, LONGLONG min, LONGLONG max)
1236{
1237 char* endptr = NULL;
1238 long long rc = 0;
1239
1240 if (!value || !result)
1241 return FALSE;
1242
1243 errno = 0;
1244 rc = _strtoi64(value, &endptr, 0);
1245
1246 if (errno != 0)
1247 return FALSE;
1248
1249 if (endptr == value)
1250 return FALSE;
1251
1252 if ((rc < min) || (rc > max))
1253 return FALSE;
1254
1255 *result = rc;
1256 return TRUE;
1257}
1258
1259static BOOL parsing_fail(const char* key, const char* type, const char* value)
1260{
1261 WLog_ERR(TAG, "Failed to parse key [%s] of type [%s]: value [%s]", key, type, value);
1262 return FALSE;
1263}
1264
1265BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name, const char* value)
1266{
1267 ULONGLONG uval = 0;
1268 LONGLONG ival = 0;
1269 SSIZE_T type = 0;
1270
1271 if (!settings || !name)
1272 return FALSE;
1273
1274 const SSIZE_T i = freerdp_settings_get_key_for_name(name);
1275 if (i < 0)
1276 {
1277 WLog_ERR(TAG, "Invalid settings key [%s]", name);
1278 return FALSE;
1279 }
1280
1281 const SSIZE_T index = i;
1282
1283 type = freerdp_settings_get_type_for_key(index);
1284 switch (type)
1285 {
1286
1287 case RDP_SETTINGS_TYPE_BOOL:
1288 {
1289 const BOOL val = (_strnicmp(value, "TRUE", 5) == 0) || (_strnicmp(value, "ON", 5) == 0);
1290 const BOOL nval =
1291 (_strnicmp(value, "FALSE", 6) == 0) || (_strnicmp(value, "OFF", 6) == 0);
1292 if (!val && !nval)
1293 return parsing_fail(name, "BOOL", value);
1294
1295 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1296 return freerdp_settings_set_bool(settings, (FreeRDP_Settings_Keys_Bool)index, val);
1297 }
1298 case RDP_SETTINGS_TYPE_UINT16:
1299 if (!value_to_uint(value, &uval, 0, UINT16_MAX))
1300 return parsing_fail(name, "UINT16", value);
1301
1302 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1303 if (!freerdp_settings_set_uint16(settings, (FreeRDP_Settings_Keys_UInt16)index,
1304 (UINT16)uval))
1305 return parsing_fail(name, "UINT16", value);
1306 return TRUE;
1307
1308 case RDP_SETTINGS_TYPE_INT16:
1309 if (!value_to_int(value, &ival, INT16_MIN, INT16_MAX))
1310 return parsing_fail(name, "INT16", value);
1311
1312 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1313 if (!freerdp_settings_set_int16(settings, (FreeRDP_Settings_Keys_Int16)index,
1314 (INT16)ival))
1315 return parsing_fail(name, "INT16", value);
1316 return TRUE;
1317 case RDP_SETTINGS_TYPE_UINT32:
1318 if (!value_to_uint(value, &uval, 0, UINT32_MAX))
1319 return parsing_fail(name, "UINT32", value);
1320
1321 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1322 if (!freerdp_settings_set_uint32(settings, (FreeRDP_Settings_Keys_UInt32)index,
1323 (UINT32)uval))
1324 return parsing_fail(name, "UINT32", value);
1325 return TRUE;
1326 case RDP_SETTINGS_TYPE_INT32:
1327 if (!value_to_int(value, &ival, INT32_MIN, INT32_MAX))
1328 return parsing_fail(name, "INT32", value);
1329
1330 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1331 if (!freerdp_settings_set_int32(settings, (FreeRDP_Settings_Keys_Int32)index,
1332 (INT32)ival))
1333 return parsing_fail(name, "INT32", value);
1334 return TRUE;
1335 case RDP_SETTINGS_TYPE_UINT64:
1336 if (!value_to_uint(value, &uval, 0, UINT64_MAX))
1337 return parsing_fail(name, "UINT64", value);
1338
1339 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1340 if (!freerdp_settings_set_uint64(settings, (FreeRDP_Settings_Keys_UInt64)index, uval))
1341 return parsing_fail(name, "UINT64", value);
1342 return TRUE;
1343 case RDP_SETTINGS_TYPE_INT64:
1344 if (!value_to_int(value, &ival, INT64_MIN, INT64_MAX))
1345 return parsing_fail(name, "INT64", value);
1346
1347 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1348 if (!freerdp_settings_set_int64(settings, (FreeRDP_Settings_Keys_Int64)index, ival))
1349 return parsing_fail(name, "INT64", value);
1350 return TRUE;
1351
1352 case RDP_SETTINGS_TYPE_STRING:
1353 // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
1354 return freerdp_settings_set_string(settings, (FreeRDP_Settings_Keys_String)index,
1355 value);
1356 case RDP_SETTINGS_TYPE_POINTER:
1357 return parsing_fail(name, "POINTER", value);
1358 default:
1359 return FALSE;
1360 }
1361 return FALSE;
1362}
1363
1364BOOL freerdp_settings_set_pointer_len_(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
1365 FreeRDP_Settings_Keys_UInt32 lenId, const void* data,
1366 size_t len, size_t size)
1367{
1368 BOOL rc = FALSE;
1369 void* copy = NULL;
1370 void* old = freerdp_settings_get_pointer_writable(settings, id);
1371 free(old);
1372 if (!freerdp_settings_set_pointer(settings, id, NULL))
1373 return FALSE;
1374 if (lenId != FreeRDP_UINT32_UNUSED)
1375 {
1376 if (!freerdp_settings_set_uint32(settings, lenId, 0))
1377 return FALSE;
1378 }
1379
1380 if (len > UINT32_MAX)
1381 return FALSE;
1382 if (len == 0)
1383 return TRUE;
1384 copy = calloc(len, size);
1385 if (!copy)
1386 return FALSE;
1387 if (data)
1388 memcpy(copy, data, len * size);
1389 rc = freerdp_settings_set_pointer(settings, id, copy);
1390 if (!rc)
1391 {
1392 free(copy);
1393 return FALSE;
1394 }
1395
1396 // freerdp_settings_set_pointer takes ownership of copy
1397 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
1398 if (lenId == FreeRDP_UINT32_UNUSED)
1399 return TRUE;
1400 return freerdp_settings_set_uint32(settings, lenId, (UINT32)len);
1401}
1402
1403const void* freerdp_settings_get_pointer(const rdpSettings* settings,
1404 FreeRDP_Settings_Keys_Pointer id)
1405{
1406 union
1407 {
1408 const rdpSettings* pc;
1409 rdpSettings* p;
1410 } cnv;
1411 cnv.pc = settings;
1412 return freerdp_settings_get_pointer_writable(cnv.p, id);
1413}
1414
1415BOOL freerdp_settings_set_pointer_len(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
1416 const void* data, size_t len)
1417{
1418 union
1419 {
1420 const void* cv;
1421 void* v;
1422 } cnv;
1423
1424 cnv.cv = data;
1425 if (!settings)
1426 return FALSE;
1427
1428 switch (id)
1429 {
1430 case FreeRDP_RdpServerCertificate:
1431 freerdp_certificate_free(settings->RdpServerCertificate);
1432
1433 if (len > 1)
1434 {
1435 WLog_ERR(TAG, "FreeRDP_RdpServerCertificate::len must be 0 or 1");
1436 return FALSE;
1437 }
1438 settings->RdpServerCertificate = cnv.v;
1439 if (!settings->RdpServerCertificate && (len > 0))
1440 {
1441 settings->RdpServerCertificate = freerdp_certificate_new();
1442 if (!settings->RdpServerCertificate)
1443 return FALSE;
1444 }
1445 return TRUE;
1446 case FreeRDP_RdpServerRsaKey:
1447 freerdp_key_free(settings->RdpServerRsaKey);
1448 if (len > 1)
1449 {
1450 WLog_ERR(TAG, "FreeRDP_RdpServerRsaKey::len must be 0 or 1");
1451 return FALSE;
1452 }
1453 settings->RdpServerRsaKey = (rdpPrivateKey*)cnv.v;
1454 if (!settings->RdpServerRsaKey && (len > 0))
1455 {
1456 settings->RdpServerRsaKey = freerdp_key_new();
1457 if (!settings->RdpServerRsaKey)
1458 return FALSE;
1459 }
1460 return TRUE;
1461 case FreeRDP_RedirectionPassword:
1462 return freerdp_settings_set_pointer_len_(
1463 settings, id, FreeRDP_RedirectionPasswordLength, data, len, sizeof(char));
1464 case FreeRDP_RedirectionTsvUrl:
1465 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_RedirectionTsvUrlLength,
1466 data, len, sizeof(char));
1467 case FreeRDP_RedirectionTargetCertificate:
1468 freerdp_certificate_free(settings->RedirectionTargetCertificate);
1469
1470 if (len > 1)
1471 {
1472 WLog_ERR(TAG, "FreeRDP_RedirectionTargetCertificate::len must be 0 or 1");
1473 return FALSE;
1474 }
1475 settings->RedirectionTargetCertificate = cnv.v;
1476 if (!settings->RedirectionTargetCertificate && (len > 0))
1477 {
1478 settings->RedirectionTargetCertificate = freerdp_certificate_new();
1479 if (!settings->RedirectionTargetCertificate)
1480 return FALSE;
1481 }
1482 return TRUE;
1483 case FreeRDP_RedirectionGuid:
1484 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_RedirectionGuidLength,
1485 data, len, sizeof(BYTE));
1486 case FreeRDP_LoadBalanceInfo:
1487 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_LoadBalanceInfoLength,
1488 data, len, sizeof(char));
1489 case FreeRDP_ServerRandom:
1490 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerRandomLength, data,
1491 len, sizeof(char));
1492 case FreeRDP_ClientRandom:
1493 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ClientRandomLength, data,
1494 len, sizeof(char));
1495 case FreeRDP_ServerCertificate:
1496 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_ServerCertificateLength,
1497 data, len, sizeof(char));
1498 case FreeRDP_TargetNetAddresses:
1499 if (!freerdp_target_net_addresses_resize(settings, len))
1500 return FALSE;
1501 if (data == NULL)
1502 target_net_addresses_free(settings, 0);
1503 return TRUE;
1504 case FreeRDP_ServerLicenseProductIssuers:
1505 if (data == NULL)
1506 freerdp_server_license_issuers_free(settings);
1507 return freerdp_settings_set_pointer_len_(
1508 settings, id, FreeRDP_ServerLicenseProductIssuersCount, data, len, sizeof(char*));
1509 case FreeRDP_TargetNetPorts:
1510 if (!freerdp_target_net_addresses_resize(settings, len))
1511 return FALSE;
1512 if (data == NULL)
1513 {
1514 for (size_t x = 0; x < len; x++)
1515 settings->TargetNetPorts[x] = 0;
1516 }
1517 return TRUE;
1518 case FreeRDP_DeviceArray:
1519 if (data == NULL)
1520 freerdp_device_collection_free(settings);
1521 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_DeviceArraySize, data,
1522 len, sizeof(RDPDR_DEVICE*));
1523 case FreeRDP_ChannelDefArray:
1524 if ((len > 0) && (len < CHANNEL_MAX_COUNT))
1525 WLog_WARN(TAG,
1526 "FreeRDP_ChannelDefArray::len expected to be >= %" PRIu32
1527 ", but have %" PRIu32,
1528 CHANNEL_MAX_COUNT, len);
1529 return freerdp_settings_set_pointer_len_(settings, FreeRDP_ChannelDefArray,
1530 FreeRDP_ChannelDefArraySize, data, len,
1531 sizeof(CHANNEL_DEF));
1532 case FreeRDP_MonitorDefArray:
1533 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_MonitorDefArraySize,
1534 data, len, sizeof(rdpMonitor));
1535 case FreeRDP_ClientAutoReconnectCookie:
1536 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1537 sizeof(ARC_CS_PRIVATE_PACKET));
1538 case FreeRDP_ServerAutoReconnectCookie:
1539 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1540 sizeof(ARC_SC_PRIVATE_PACKET));
1541 case FreeRDP_ClientTimeZone:
1542 if (len > 1)
1543 {
1544 WLog_ERR(TAG, "FreeRDP_ClientTimeZone::len must be 0 or 1");
1545 return FALSE;
1546 }
1547 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1548 sizeof(TIME_ZONE_INFORMATION));
1549 case FreeRDP_BitmapCacheV2CellInfo:
1550 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_BitmapCacheV2NumCells,
1551 data, len, sizeof(BITMAP_CACHE_V2_CELL_INFO));
1552 case FreeRDP_GlyphCache:
1553 if ((len != 0) && (len != 10))
1554 {
1555 WLog_ERR(TAG, "FreeRDP_GlyphCache::len must be 0 or 10");
1556 return FALSE;
1557 }
1558 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1559 sizeof(GLYPH_CACHE_DEFINITION));
1560 case FreeRDP_FragCache:
1561 if (len > 1)
1562 {
1563 WLog_ERR(TAG, "FreeRDP_FragCache::len must be 0 or 1");
1564 return FALSE;
1565 }
1566 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1567 sizeof(GLYPH_CACHE_DEFINITION));
1568 case FreeRDP_StaticChannelArray:
1569 if (data == NULL)
1570 freerdp_static_channel_collection_free(settings);
1571 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_StaticChannelArraySize,
1572 data, len, sizeof(ADDIN_ARGV*));
1573 case FreeRDP_DynamicChannelArray:
1574 if (data == NULL)
1575 freerdp_dynamic_channel_collection_free(settings);
1576 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_DynamicChannelArraySize,
1577 data, len, sizeof(ADDIN_ARGV*));
1578 case FreeRDP_ReceivedCapabilityData:
1579 if (!freerdp_capability_buffer_resize(settings, len))
1580 return FALSE;
1581 if (data == NULL)
1582 {
1583 freerdp_capability_data_free(settings, 0, FALSE);
1584 }
1585 return TRUE;
1586 case FreeRDP_ReceivedCapabilities:
1587 if (!freerdp_capability_buffer_resize(settings, len))
1588 return FALSE;
1589 if (data == NULL)
1590 {
1591 for (size_t x = 0; x < settings->ReceivedCapabilitiesSize; x++)
1592 {
1593 settings->ReceivedCapabilities[x] = 0;
1594 }
1595 }
1596 return TRUE;
1597 case FreeRDP_OrderSupport:
1598 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_UINT32_UNUSED, data, len,
1599 sizeof(char));
1600
1601 case FreeRDP_MonitorIds:
1602 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_NumMonitorIds, data, len,
1603 sizeof(UINT32));
1604
1605 case FreeRDP_ReceivedCapabilityDataSizes:
1606 if (!freerdp_capability_buffer_resize(settings, len))
1607 return FALSE;
1608 if (data == NULL)
1609 {
1610 for (size_t x = 0; x < settings->ReceivedCapabilitiesSize; x++)
1611 settings->ReceivedCapabilityDataSizes[x] = 0;
1612 }
1613 return TRUE;
1614
1615 case FreeRDP_Password51:
1616 return freerdp_settings_set_pointer_len_(settings, id, FreeRDP_Password51Length, data,
1617 len, sizeof(char));
1618 default:
1619 if ((data == NULL) && (len == 0))
1620 {
1621 freerdp_settings_set_pointer(settings, id, NULL);
1622 }
1623 else
1624 WLog_WARN(TAG, "Invalid id %" PRIuz, id);
1625 return FALSE;
1626 }
1627}
1628
1629void* freerdp_settings_get_pointer_array_writable(const rdpSettings* settings,
1630 FreeRDP_Settings_Keys_Pointer id, size_t offset)
1631{
1632 size_t max = 0;
1633 if (!settings)
1634 return NULL;
1635 switch (id)
1636 {
1637 case FreeRDP_ClientAutoReconnectCookie:
1638 max = 1;
1639 if ((offset >= max) || !settings->ClientAutoReconnectCookie)
1640 goto fail;
1641 return &settings->ClientAutoReconnectCookie[offset];
1642 case FreeRDP_ServerAutoReconnectCookie:
1643 max = 1;
1644 if ((offset >= max) || !settings->ServerAutoReconnectCookie)
1645 goto fail;
1646 return &settings->ServerAutoReconnectCookie[offset];
1647 case FreeRDP_ServerCertificate:
1648 max = freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength);
1649 if (offset >= max)
1650 goto fail;
1651 return &settings->ServerCertificate[offset];
1652 case FreeRDP_ServerRandom:
1653 max = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
1654 if (offset >= max)
1655 goto fail;
1656 return &settings->ServerRandom[offset];
1657 case FreeRDP_ClientRandom:
1658 max = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
1659 if (offset >= max)
1660 goto fail;
1661 return &settings->ClientRandom[offset];
1662 case FreeRDP_LoadBalanceInfo:
1663 max = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
1664 if (offset >= max)
1665 goto fail;
1666 return &settings->LoadBalanceInfo[offset];
1667
1668 case FreeRDP_RedirectionTsvUrl:
1669 max = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionTsvUrlLength);
1670 if (offset >= max)
1671 goto fail;
1672 return &settings->RedirectionTsvUrl[offset];
1673
1674 case FreeRDP_RedirectionPassword:
1675 max = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength);
1676 if (offset >= max)
1677 goto fail;
1678 return &settings->RedirectionPassword[offset];
1679
1680 case FreeRDP_OrderSupport:
1681 max = 32;
1682 if (offset >= max)
1683 goto fail;
1684 return &settings->OrderSupport[offset];
1685 case FreeRDP_MonitorIds:
1686 max = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
1687 if (offset >= max)
1688 goto fail;
1689 return &settings->MonitorIds[offset];
1690 case FreeRDP_MonitorDefArray:
1691 max = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
1692 if (offset >= max)
1693 goto fail;
1694 return &settings->MonitorDefArray[offset];
1695 case FreeRDP_ChannelDefArray:
1696 max = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
1697 if (offset >= max)
1698 goto fail;
1699 return &settings->ChannelDefArray[offset];
1700 case FreeRDP_DeviceArray:
1701 max = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
1702 if (offset >= max)
1703 goto fail;
1704 return settings->DeviceArray[offset];
1705 case FreeRDP_StaticChannelArray:
1706 max = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
1707 if (offset >= max)
1708 goto fail;
1709 return settings->StaticChannelArray[offset];
1710 case FreeRDP_DynamicChannelArray:
1711 max = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
1712 if (offset >= max)
1713 goto fail;
1714 return settings->DynamicChannelArray[offset];
1715 case FreeRDP_FragCache:
1716 max = 1;
1717 if (offset >= max)
1718 goto fail;
1719 return &settings->FragCache[offset];
1720 case FreeRDP_GlyphCache:
1721 max = 10;
1722 if (offset >= max)
1723 goto fail;
1724 return &settings->GlyphCache[offset];
1725 case FreeRDP_BitmapCacheV2CellInfo:
1726 max = freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
1727 if (offset >= max)
1728 goto fail;
1729 return &settings->BitmapCacheV2CellInfo[offset];
1730 case FreeRDP_ReceivedCapabilities:
1731 max = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
1732 if (offset >= max)
1733 goto fail;
1734 return &settings->ReceivedCapabilities[offset];
1735 case FreeRDP_TargetNetAddresses:
1736 max = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
1737 if (offset >= max)
1738 goto fail;
1739 WINPR_ASSERT(settings->TargetNetAddresses);
1740 return settings->TargetNetAddresses[offset];
1741 case FreeRDP_TargetNetPorts:
1742 max = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
1743 if (offset >= max)
1744 goto fail;
1745 WINPR_ASSERT(settings->TargetNetPorts);
1746 return &settings->TargetNetPorts[offset];
1747 case FreeRDP_ClientTimeZone:
1748 max = 1;
1749 if (offset >= max)
1750 goto fail;
1751 return settings->ClientTimeZone;
1752 case FreeRDP_RdpServerCertificate:
1753 max = 1;
1754 if (offset >= max)
1755 goto fail;
1756 return settings->RdpServerCertificate;
1757 case FreeRDP_RdpServerRsaKey:
1758 max = 1;
1759 if (offset >= max)
1760 goto fail;
1761 return settings->RdpServerRsaKey;
1762 case FreeRDP_ServerLicenseProductIssuers:
1763 max = freerdp_settings_get_uint32(settings, FreeRDP_ServerLicenseProductIssuersCount);
1764 if (offset >= max)
1765 goto fail;
1766 return settings->ServerLicenseProductIssuers[offset];
1767 case FreeRDP_ReceivedCapabilityData:
1768 max = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
1769 if (offset >= max)
1770 goto fail;
1771 WINPR_ASSERT(settings->ReceivedCapabilityData);
1772 return settings->ReceivedCapabilityData[offset];
1773
1774 case FreeRDP_ReceivedCapabilityDataSizes:
1775 max = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
1776 if (offset >= max)
1777 goto fail;
1778 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
1779 return &settings->ReceivedCapabilityDataSizes[offset];
1780 default:
1781 WLog_WARN(TAG, "Invalid id %s [%" PRIuz "]", freerdp_settings_get_name_for_key(id), id);
1782 return NULL;
1783 }
1784
1785fail:
1786 WLog_WARN(TAG, "Invalid offset for %s [%" PRIuz "]: size=%" PRIuz ", offset=%" PRIuz,
1787 freerdp_settings_get_name_for_key(id), id, max, offset);
1788 return NULL;
1789}
1790
1791BOOL freerdp_settings_set_pointer_array(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
1792 size_t offset, const void* data)
1793{
1794 size_t maxOffset = 0;
1795 if (!settings)
1796 return FALSE;
1797 switch (id)
1798 {
1799 case FreeRDP_ClientAutoReconnectCookie:
1800 maxOffset = 1;
1801 if ((offset >= maxOffset) || !data || !settings->ClientAutoReconnectCookie)
1802 goto fail;
1803 settings->ClientAutoReconnectCookie[offset] = *(const ARC_CS_PRIVATE_PACKET*)data;
1804 return TRUE;
1805 case FreeRDP_ServerAutoReconnectCookie:
1806 maxOffset = 1;
1807 if ((offset >= maxOffset) || !data || !settings->ServerAutoReconnectCookie)
1808 goto fail;
1809 settings->ServerAutoReconnectCookie[offset] = *(const ARC_SC_PRIVATE_PACKET*)data;
1810 return TRUE;
1811 case FreeRDP_ServerCertificate:
1812 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength);
1813 if ((offset >= maxOffset) || !data)
1814 goto fail;
1815 settings->ServerCertificate[offset] = *(const BYTE*)data;
1816 return TRUE;
1817 case FreeRDP_DeviceArray:
1818 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
1819 if (offset >= maxOffset)
1820 goto fail;
1821 freerdp_device_free(settings->DeviceArray[offset]);
1822 settings->DeviceArray[offset] = freerdp_device_clone(data);
1823 return TRUE;
1824 case FreeRDP_TargetNetAddresses:
1825 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
1826 if ((offset >= maxOffset) || !data)
1827 goto fail;
1828 WINPR_ASSERT(settings->TargetNetAddresses);
1829 free(settings->TargetNetAddresses[offset]);
1830 settings->TargetNetAddresses[offset] = _strdup((const char*)data);
1831 return settings->TargetNetAddresses[offset] != NULL;
1832 case FreeRDP_TargetNetPorts:
1833 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
1834 if ((offset >= maxOffset) || !data)
1835 goto fail;
1836 WINPR_ASSERT(settings->TargetNetPorts);
1837 settings->TargetNetPorts[offset] = *((const UINT32*)data);
1838 return TRUE;
1839 case FreeRDP_StaticChannelArray:
1840 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
1841 if ((offset >= maxOffset) || !data)
1842 goto fail;
1843 freerdp_addin_argv_free(settings->StaticChannelArray[offset]);
1844 settings->StaticChannelArray[offset] = freerdp_addin_argv_clone(data);
1845 return TRUE;
1846 case FreeRDP_DynamicChannelArray:
1847 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
1848 if ((offset >= maxOffset) || !data)
1849 goto fail;
1850 freerdp_addin_argv_free(settings->DynamicChannelArray[offset]);
1851 settings->DynamicChannelArray[offset] = freerdp_addin_argv_clone(data);
1852 return TRUE;
1853 case FreeRDP_BitmapCacheV2CellInfo:
1854 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
1855 if ((offset >= maxOffset) || !data)
1856 goto fail;
1857 {
1858 const BITMAP_CACHE_V2_CELL_INFO* cdata = (const BITMAP_CACHE_V2_CELL_INFO*)data;
1859 settings->BitmapCacheV2CellInfo[offset] = *cdata;
1860 }
1861 return TRUE;
1862 case FreeRDP_ServerRandom:
1863 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
1864 if ((offset >= maxOffset) || !data)
1865 goto fail;
1866 settings->ServerRandom[offset] = *(const BYTE*)data;
1867 return TRUE;
1868 case FreeRDP_ClientRandom:
1869 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
1870 if ((offset >= maxOffset) || !data)
1871 goto fail;
1872 settings->ClientRandom[offset] = *(const BYTE*)data;
1873 return TRUE;
1874 case FreeRDP_LoadBalanceInfo:
1875 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
1876 if ((offset >= maxOffset) || !data)
1877 goto fail;
1878 settings->LoadBalanceInfo[offset] = *(const BYTE*)data;
1879 return TRUE;
1880 case FreeRDP_RedirectionTsvUrl:
1881 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionTsvUrlLength);
1882 if ((offset >= maxOffset) || !data)
1883 goto fail;
1884 settings->RedirectionTsvUrl[offset] = *(const BYTE*)data;
1885 return TRUE;
1886 case FreeRDP_RedirectionPassword:
1887 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength);
1888 if ((offset >= maxOffset) || !data)
1889 goto fail;
1890 settings->RedirectionPassword[offset] = *(const BYTE*)data;
1891 return TRUE;
1892 case FreeRDP_OrderSupport:
1893 maxOffset = 32;
1894 if (!settings->OrderSupport)
1895 goto fail;
1896 if ((offset >= maxOffset) || !data)
1897 goto fail;
1898 settings->OrderSupport[offset] = *(const BOOL*)data ? 1 : 0;
1899 return TRUE;
1900 case FreeRDP_GlyphCache:
1901 maxOffset = 10;
1902 if (!settings->GlyphCache)
1903 goto fail;
1904 if ((offset >= maxOffset) || !data)
1905 goto fail;
1906 settings->GlyphCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data;
1907 return TRUE;
1908 case FreeRDP_FragCache:
1909 maxOffset = 1;
1910 if (!settings->FragCache)
1911 goto fail;
1912 if ((offset >= maxOffset) || !data)
1913 goto fail;
1914 settings->FragCache[offset] = *(const GLYPH_CACHE_DEFINITION*)data;
1915 return TRUE;
1916 case FreeRDP_MonitorIds:
1917 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
1918 if ((offset >= maxOffset) || !data)
1919 goto fail;
1920 settings->MonitorIds[offset] = *(const UINT32*)data;
1921 return TRUE;
1922 case FreeRDP_ChannelDefArray:
1923 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
1924 if ((offset >= maxOffset) || !data)
1925 goto fail;
1926 settings->ChannelDefArray[offset] = *(const CHANNEL_DEF*)data;
1927 return TRUE;
1928 case FreeRDP_MonitorDefArray:
1929 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
1930 if ((offset >= maxOffset) || !data)
1931 goto fail;
1932 settings->MonitorDefArray[offset] = *(const rdpMonitor*)data;
1933 return TRUE;
1934
1935 case FreeRDP_ClientTimeZone:
1936 maxOffset = 1;
1937 if ((offset >= maxOffset) || !data || !settings->ClientTimeZone)
1938 goto fail;
1939 settings->ClientTimeZone[offset] = *(const TIME_ZONE_INFORMATION*)data;
1940 return TRUE;
1941
1942 case FreeRDP_ServerLicenseProductIssuers:
1943 maxOffset =
1944 freerdp_settings_get_uint32(settings, FreeRDP_ServerLicenseProductIssuersCount);
1945 if ((offset >= maxOffset) || !settings->ServerLicenseProductIssuers)
1946 goto fail;
1947 free(settings->ServerLicenseProductIssuers[offset]);
1948 settings->ServerLicenseProductIssuers[offset] = NULL;
1949 if (data)
1950 settings->ServerLicenseProductIssuers[offset] = _strdup((const char*)data);
1951 return TRUE;
1952
1953 case FreeRDP_ReceivedCapabilityData:
1954 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
1955 if (offset >= maxOffset)
1956 goto fail;
1957 WINPR_ASSERT(settings->ReceivedCapabilityData);
1958 settings->ReceivedCapabilityData[offset] = WINPR_CAST_CONST_PTR_AWAY(data, BYTE*);
1959 return TRUE;
1960 case FreeRDP_ReceivedCapabilityDataSizes:
1961 maxOffset = freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
1962 if (offset >= maxOffset)
1963 goto fail;
1964 WINPR_ASSERT(settings->ReceivedCapabilityDataSizes);
1965 settings->ReceivedCapabilityDataSizes[offset] = *(const uint32_t*)data;
1966 return TRUE;
1967 default:
1968 WLog_WARN(TAG, "Invalid id %s [%" PRIuz "]", freerdp_settings_get_name_for_key(id), id);
1969 return FALSE;
1970 }
1971
1972fail:
1973 WLog_WARN(TAG, "[%s] Invalid offset=%" PRIuz " [%" PRIuz "] or NULL data=%p",
1974 freerdp_settings_get_name_for_key(id), offset, maxOffset, data);
1975 return FALSE;
1976}
1977
1978const void* freerdp_settings_get_pointer_array(const rdpSettings* settings,
1979 FreeRDP_Settings_Keys_Pointer id, size_t offset)
1980{
1981 return freerdp_settings_get_pointer_array_writable(settings, id, offset);
1982}
1983
1984UINT32 freerdp_settings_get_codecs_flags(const rdpSettings* settings)
1985{
1986 UINT32 flags = FREERDP_CODEC_ALL;
1987 if (settings->RemoteFxCodec == FALSE)
1988 {
1989 flags &= (uint32_t)~FREERDP_CODEC_REMOTEFX;
1990 }
1991 if (settings->NSCodec == FALSE)
1992 {
1993 flags &= (uint32_t)~FREERDP_CODEC_NSCODEC;
1994 }
1995 /*TODO: check other codecs flags */
1996 return flags;
1997}
1998
1999const char* freerdp_settings_get_server_name(const rdpSettings* settings)
2000{
2001 WINPR_ASSERT(settings);
2002 const char* hostname = settings->ServerHostname;
2003
2004 if (settings->UserSpecifiedServerName)
2005 hostname = settings->UserSpecifiedServerName;
2006
2007 return hostname;
2008}
2009
2010#if defined(WITH_FREERDP_DEPRECATED)
2011ADDIN_ARGV* freerdp_static_channel_clone(ADDIN_ARGV* channel)
2012{
2013 return freerdp_addin_argv_clone(channel);
2014}
2015
2016ADDIN_ARGV* freerdp_dynamic_channel_clone(ADDIN_ARGV* channel)
2017{
2018 return freerdp_addin_argv_clone(channel);
2019}
2020#endif
2021
2022BOOL freerdp_target_net_addresses_copy(rdpSettings* settings, char** addresses, UINT32 count)
2023{
2024 WINPR_ASSERT(settings);
2025 WINPR_ASSERT(addresses);
2026
2027 if (!freerdp_target_net_adresses_reset(settings, count))
2028 return FALSE;
2029
2030 for (UINT32 i = 0; i < settings->TargetNetAddressCount; i++)
2031 {
2032 const char* address = addresses[i];
2033 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_TargetNetAddresses, i, address))
2034 {
2035 freerdp_target_net_addresses_free(settings);
2036 return FALSE;
2037 }
2038 }
2039
2040 return TRUE;
2041}
2042
2043BOOL freerdp_device_equal(const RDPDR_DEVICE* what, const RDPDR_DEVICE* expect)
2044{
2045 if (!what && !expect)
2046 return TRUE;
2047 if (!what || !expect)
2048 return FALSE;
2049
2050 if (what->Id != expect->Id)
2051 return FALSE;
2052 if (what->Type != expect->Type)
2053 return FALSE;
2054 if (what->Name && expect->Name)
2055 {
2056 if (strcmp(what->Name, expect->Name) != 0)
2057 return FALSE;
2058 }
2059 else
2060 {
2061 if (what->Name != expect->Name)
2062 return FALSE;
2063 }
2064
2065 switch (what->Type)
2066 {
2067 case RDPDR_DTYP_PRINT:
2068 {
2069 const RDPDR_PRINTER* a = (const RDPDR_PRINTER*)what;
2070 const RDPDR_PRINTER* b = (const RDPDR_PRINTER*)expect;
2071 if (a->DriverName && b->DriverName)
2072 return strcmp(a->DriverName, b->DriverName) == 0;
2073 return a->DriverName == b->DriverName;
2074 }
2075
2076 case RDPDR_DTYP_SERIAL:
2077 {
2078 const RDPDR_SERIAL* a = (const RDPDR_SERIAL*)what;
2079 const RDPDR_SERIAL* b = (const RDPDR_SERIAL*)expect;
2080
2081 if (a->Path && b->Path)
2082 {
2083 if (strcmp(a->Path, b->Path) != 0)
2084 return FALSE;
2085 }
2086 else if (a->Path != b->Path)
2087 return FALSE;
2088
2089 if (a->Driver && b->Driver)
2090 {
2091 if (strcmp(a->Driver, b->Driver) != 0)
2092 return FALSE;
2093 }
2094 else if (a->Driver != b->Driver)
2095 return FALSE;
2096 if (a->Permissive && b->Permissive)
2097 return strcmp(a->Permissive, b->Permissive) == 0;
2098 return a->Permissive == b->Permissive;
2099 }
2100
2101 case RDPDR_DTYP_PARALLEL:
2102 {
2103 const RDPDR_PARALLEL* a = (const RDPDR_PARALLEL*)what;
2104 const RDPDR_PARALLEL* b = (const RDPDR_PARALLEL*)expect;
2105 if (a->Path && b->Path)
2106 return strcmp(a->Path, b->Path) == 0;
2107 return a->Path == b->Path;
2108 }
2109
2110 case RDPDR_DTYP_SMARTCARD:
2111 break;
2112 case RDPDR_DTYP_FILESYSTEM:
2113 {
2114 const RDPDR_DRIVE* a = (const RDPDR_DRIVE*)what;
2115 const RDPDR_DRIVE* b = (const RDPDR_DRIVE*)expect;
2116 if (a->automount != b->automount)
2117 return FALSE;
2118 if (a->Path && b->Path)
2119 return strcmp(a->Path, b->Path) == 0;
2120 return a->Path == b->Path;
2121 }
2122
2123 default:
2124 return FALSE;
2125 }
2126
2127 return TRUE;
2128}
2129
2130const char* freerdp_rail_support_flags_to_string(UINT32 flags, char* buffer, size_t length)
2131{
2132 const UINT32 mask =
2133 RAIL_LEVEL_SUPPORTED | RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED |
2134 RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED | RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED |
2135 RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED | RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED |
2136 RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED | RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED;
2137
2138 if (flags & RAIL_LEVEL_SUPPORTED)
2139 winpr_str_append("RAIL_LEVEL_SUPPORTED", buffer, length, "|");
2140 if (flags & RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED)
2141 winpr_str_append("RAIL_LEVEL_DOCKED_LANGBAR_SUPPORTED", buffer, length, "|");
2142 if (flags & RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED)
2143 winpr_str_append("RAIL_LEVEL_SHELL_INTEGRATION_SUPPORTED", buffer, length, "|");
2144 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2145 winpr_str_append("RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length, "|");
2146 if (flags & RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED)
2147 winpr_str_append("RAIL_LEVEL_SERVER_TO_CLIENT_IME_SYNC_SUPPORTED", buffer, length, "|");
2148 if (flags & RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED)
2149 winpr_str_append("RAIL_LEVEL_HIDE_MINIMIZED_APPS_SUPPORTED", buffer, length, "|");
2150 if (flags & RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED)
2151 winpr_str_append("RAIL_LEVEL_WINDOW_CLOAKING_SUPPORTED", buffer, length, "|");
2152 if (flags & RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED)
2153 winpr_str_append("RAIL_LEVEL_HANDSHAKE_EX_SUPPORTED", buffer, length, "|");
2154 if (flags & RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED)
2155 winpr_str_append("RAIL_LEVEL_LANGUAGE_IME_SYNC_SUPPORTED", buffer, length, "|");
2156 if ((flags & ~mask) != 0)
2157 {
2158 char tbuffer[64] = { 0 };
2159 (void)_snprintf(tbuffer, sizeof(tbuffer), "RAIL_FLAG_UNKNOWN 0x%08" PRIx32, flags & mask);
2160 winpr_str_append(tbuffer, buffer, length, "|");
2161 }
2162 return buffer;
2163}
2164
2165BOOL freerdp_settings_update_from_caps(rdpSettings* settings, const BYTE* capsFlags,
2166 const BYTE** capsData, const UINT32* capsSizes,
2167 UINT32 capsCount, BOOL serverReceivedCaps)
2168{
2169 WINPR_ASSERT(settings);
2170 WINPR_ASSERT(capsFlags || (capsCount == 0));
2171 WINPR_ASSERT(capsData || (capsCount == 0));
2172 WINPR_ASSERT(capsSizes || (capsCount == 0));
2173 WINPR_ASSERT(capsCount <= UINT16_MAX);
2174
2175 wLog* log = WLog_Get(TAG);
2176
2177 for (UINT32 x = 0; x < capsCount; x++)
2178 {
2179 if (capsFlags[x])
2180 {
2181 wStream buffer = { 0 };
2182 wStream* sub = Stream_StaticConstInit(&buffer, capsData[x], capsSizes[x]);
2183
2184 if (!rdp_read_capability_set(log, sub, (UINT16)x, settings, serverReceivedCaps))
2185 return FALSE;
2186 }
2187 }
2188
2189 return TRUE;
2190}
2191
2192const char* freerdp_rdp_version_string(UINT32 version)
2193{
2194 switch (version)
2195 {
2196 case RDP_VERSION_4:
2197 return "RDP_VERSION_4";
2198 case RDP_VERSION_5_PLUS:
2199 return "RDP_VERSION_5_PLUS";
2200 case RDP_VERSION_10_0:
2201 return "RDP_VERSION_10_0";
2202 case RDP_VERSION_10_1:
2203 return "RDP_VERSION_10_1";
2204 case RDP_VERSION_10_2:
2205 return "RDP_VERSION_10_2";
2206 case RDP_VERSION_10_3:
2207 return "RDP_VERSION_10_3";
2208 case RDP_VERSION_10_4:
2209 return "RDP_VERSION_10_4";
2210 case RDP_VERSION_10_5:
2211 return "RDP_VERSION_10_5";
2212 case RDP_VERSION_10_6:
2213 return "RDP_VERSION_10_6";
2214 case RDP_VERSION_10_7:
2215 return "RDP_VERSION_10_7";
2216 case RDP_VERSION_10_8:
2217 return "RDP_VERSION_10_8";
2218 case RDP_VERSION_10_9:
2219 return "RDP_VERSION_10_9";
2220 case RDP_VERSION_10_10:
2221 return "RDP_VERSION_10_10";
2222 case RDP_VERSION_10_11:
2223 return "RDP_VERSION_10_11";
2224 case RDP_VERSION_10_12:
2225 return "RDP_VERSION_10_12";
2226 default:
2227 return "RDP_VERSION_UNKNOWN";
2228 }
2229}
2230
2231BOOL freerdp_settings_set_string_from_utf16(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
2232 const WCHAR* param)
2233{
2234 WINPR_ASSERT(settings);
2235
2236 if (!param)
2237 return freerdp_settings_set_string_copy_(settings, id, NULL, 0, TRUE);
2238
2239 size_t len = 0;
2240
2241 char* str = ConvertWCharToUtf8Alloc(param, &len);
2242 if (!str && (len != 0))
2243 return FALSE;
2244
2245 return freerdp_settings_set_string_(settings, id, str, len);
2246}
2247
2248BOOL freerdp_settings_set_string_from_utf16N(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
2249 const WCHAR* param, size_t length)
2250{
2251 size_t len = 0;
2252
2253 WINPR_ASSERT(settings);
2254
2255 if (!param)
2256 return freerdp_settings_set_string_copy_(settings, id, NULL, length, TRUE);
2257
2258 char* str = ConvertWCharNToUtf8Alloc(param, length, &len);
2259 if (!str && (length != 0))
2260 {
2261 /* If the input string is an empty string, but length > 0
2262 * consider the conversion a success */
2263 const size_t wlen = _wcsnlen(param, length);
2264 if (wlen != 0)
2265 return FALSE;
2266 }
2267
2268 return freerdp_settings_set_string_(settings, id, str, len);
2269}
2270
2271WCHAR* freerdp_settings_get_string_as_utf16(const rdpSettings* settings,
2272 FreeRDP_Settings_Keys_String id, size_t* pCharLen)
2273{
2274 const char* str = freerdp_settings_get_string(settings, id);
2275 if (pCharLen)
2276 *pCharLen = 0;
2277 if (!str)
2278 return NULL;
2279 return ConvertUtf8ToWCharAlloc(str, pCharLen);
2280}
2281
2282const char* freerdp_rdpdr_dtyp_string(UINT32 type)
2283{
2284 switch (type)
2285 {
2286 case RDPDR_DTYP_FILESYSTEM:
2287 return "RDPDR_DTYP_FILESYSTEM";
2288 case RDPDR_DTYP_PARALLEL:
2289 return "RDPDR_DTYP_PARALLEL";
2290 case RDPDR_DTYP_PRINT:
2291 return "RDPDR_DTYP_PRINT";
2292 case RDPDR_DTYP_SERIAL:
2293 return "RDPDR_DTYP_SERIAL";
2294 case RDPDR_DTYP_SMARTCARD:
2295 return "RDPDR_DTYP_SMARTCARD";
2296 default:
2297 return "RDPDR_DTYP_UNKNOWN";
2298 }
2299}
2300
2301const char* freerdp_encryption_level_string(UINT32 EncryptionLevel)
2302{
2303 switch (EncryptionLevel)
2304 {
2305 case ENCRYPTION_LEVEL_NONE:
2306 return "ENCRYPTION_LEVEL_NONE";
2307 case ENCRYPTION_LEVEL_LOW:
2308 return "ENCRYPTION_LEVEL_LOW";
2309 case ENCRYPTION_LEVEL_CLIENT_COMPATIBLE:
2310 return "ENCRYPTION_LEVEL_CLIENT_COMPATIBLE";
2311 case ENCRYPTION_LEVEL_HIGH:
2312 return "ENCRYPTION_LEVEL_HIGH";
2313 case ENCRYPTION_LEVEL_FIPS:
2314 return "ENCRYPTION_LEVEL_FIPS";
2315 default:
2316 return "ENCRYPTION_LEVEL_UNKNOWN";
2317 }
2318}
2319
2320const char* freerdp_encryption_methods_string(UINT32 EncryptionMethods, char* buffer, size_t size)
2321{
2322 if (EncryptionMethods == ENCRYPTION_METHOD_NONE)
2323 {
2324 winpr_str_append("ENCRYPTION_METHOD_NONE", buffer, size, "|");
2325 return buffer;
2326 }
2327
2328 if (EncryptionMethods & ENCRYPTION_METHOD_40BIT)
2329 {
2330 winpr_str_append("ENCRYPTION_METHOD_40BIT", buffer, size, "|");
2331 }
2332 if (EncryptionMethods & ENCRYPTION_METHOD_128BIT)
2333 {
2334 winpr_str_append("ENCRYPTION_METHOD_128BIT", buffer, size, "|");
2335 }
2336 if (EncryptionMethods & ENCRYPTION_METHOD_56BIT)
2337 {
2338 winpr_str_append("ENCRYPTION_METHOD_56BIT", buffer, size, "|");
2339 }
2340 if (EncryptionMethods & ENCRYPTION_METHOD_FIPS)
2341 {
2342 winpr_str_append("ENCRYPTION_METHOD_FIPS", buffer, size, "|");
2343 }
2344
2345 return buffer;
2346}
2347
2348const char* freerdp_supported_color_depths_string(UINT16 mask, char* buffer, size_t size)
2349{
2350 const UINT32 invalid = mask & ~(RNS_UD_32BPP_SUPPORT | RNS_UD_24BPP_SUPPORT |
2351 RNS_UD_16BPP_SUPPORT | RNS_UD_15BPP_SUPPORT);
2352
2353 if (mask & RNS_UD_32BPP_SUPPORT)
2354 winpr_str_append("RNS_UD_32BPP_SUPPORT", buffer, size, "|");
2355 if (mask & RNS_UD_24BPP_SUPPORT)
2356 winpr_str_append("RNS_UD_24BPP_SUPPORT", buffer, size, "|");
2357 if (mask & RNS_UD_16BPP_SUPPORT)
2358 winpr_str_append("RNS_UD_16BPP_SUPPORT", buffer, size, "|");
2359 if (mask & RNS_UD_15BPP_SUPPORT)
2360 winpr_str_append("RNS_UD_15BPP_SUPPORT", buffer, size, "|");
2361
2362 if (invalid != 0)
2363 {
2364 char str[32] = { 0 };
2365 (void)_snprintf(str, sizeof(str), "RNS_UD_INVALID[0x%04" PRIx32 "]", invalid);
2366 winpr_str_append(str, buffer, size, "|");
2367 }
2368 char hex[32] = { 0 };
2369 (void)_snprintf(hex, sizeof(hex), "[0x%04" PRIx16 "]", mask);
2370 return buffer;
2371}
2372
2373BOOL freerdp_settings_append_string(rdpSettings* settings, FreeRDP_Settings_Keys_String id,
2374 const char* separator, const char* param)
2375{
2376 const char* old = freerdp_settings_get_string(settings, id);
2377
2378 size_t len = 0;
2379 char* str = NULL;
2380
2381 if (!old)
2382 winpr_asprintf(&str, &len, "%s", param);
2383 else if (!separator)
2384 winpr_asprintf(&str, &len, "%s%s", old, param);
2385 else
2386 winpr_asprintf(&str, &len, "%s%s%s", old, separator, param);
2387
2388 const BOOL rc = freerdp_settings_set_string_len(settings, id, str, len);
2389 free(str);
2390 return rc;
2391}
2392
2393BOOL freerdp_settings_are_valid(const rdpSettings* settings)
2394{
2395 return settings != NULL;
2396}
2397
2398/* Function to sort rdpMonitor arrays:
2399 * 1. first element is primary monitor
2400 * 2. all others are sorted by coordinates of x/y
2401 */
2402static int sort_monitor_fn(const void* pva, const void* pvb)
2403{
2404 const rdpMonitor* a = pva;
2405 const rdpMonitor* b = pvb;
2406 WINPR_ASSERT(a);
2407 WINPR_ASSERT(b);
2408 if (a->is_primary && b->is_primary)
2409 return 0;
2410 if (a->is_primary)
2411 return -1;
2412 if (b->is_primary)
2413 return 1;
2414
2415 if (a->x != b->x)
2416 return a->x - b->x;
2417 if (a->y != b->y)
2418 return a->y - b->y;
2419 return 0;
2420}
2421
2422BOOL freerdp_settings_set_monitor_def_array_sorted(rdpSettings* settings,
2423 const rdpMonitor* monitors, size_t count)
2424{
2425 WINPR_ASSERT(monitors || (count == 0));
2426 if (count == 0)
2427 {
2428 if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftX, 0))
2429 return FALSE;
2430 if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftY, 0))
2431 return FALSE;
2432 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorDefArray, NULL, 0))
2433 return FALSE;
2434 return freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount, 0);
2435 }
2436
2437 // Find primary or alternatively the monitor at 0/0
2438 const rdpMonitor* primary = NULL;
2439 for (size_t x = 0; x < count; x++)
2440 {
2441 const rdpMonitor* cur = &monitors[x];
2442 if (cur->is_primary)
2443 {
2444 primary = cur;
2445 break;
2446 }
2447 }
2448 if (!primary)
2449 {
2450 for (size_t x = 0; x < count; x++)
2451 {
2452 const rdpMonitor* cur = &monitors[x];
2453 if ((cur->x == 0) && (cur->y == 0))
2454 {
2455 primary = cur;
2456 break;
2457 }
2458 }
2459 }
2460
2461 if (!primary)
2462 {
2463 WLog_ERR(TAG, "Could not find primary monitor, aborting");
2464 return FALSE;
2465 }
2466
2467 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorDefArray, NULL, count))
2468 return FALSE;
2469 rdpMonitor* sorted = freerdp_settings_get_pointer_writable(settings, FreeRDP_MonitorDefArray);
2470 WINPR_ASSERT(sorted);
2471
2472 size_t sortpos = 0;
2473
2474 /* Set primary. Ensure left/top is at 0/0 and flags contains MONITOR_PRIMARY */
2475 sorted[sortpos] = *primary;
2476 sorted[sortpos].x = 0;
2477 sorted[sortpos].y = 0;
2478 sorted[sortpos].is_primary = TRUE;
2479 sortpos++;
2480
2481 /* Set monitor shift to original layout */
2482 const INT32 offsetX = primary->x;
2483 const INT32 offsetY = primary->y;
2484 if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftX, offsetX))
2485 return FALSE;
2486 if (!freerdp_settings_set_int32(settings, FreeRDP_MonitorLocalShiftY, offsetY))
2487 return FALSE;
2488
2489 for (size_t x = 0; x < count; x++)
2490 {
2491 const rdpMonitor* cur = &monitors[x];
2492 if (cur == primary)
2493 continue;
2494
2495 rdpMonitor m = monitors[x];
2496 m.x -= offsetX;
2497 m.y -= offsetY;
2498 sorted[sortpos++] = m;
2499 }
2500
2501 // Sort remaining monitors by x/y ?
2502 qsort(sorted, count, sizeof(rdpMonitor), sort_monitor_fn);
2503
2504 return freerdp_settings_set_uint32(settings, FreeRDP_MonitorCount,
2505 WINPR_ASSERTING_INT_CAST(uint32_t, count));
2506}
2507
2508static BOOL fill_array(WINPR_JSON* array, const void* data, size_t length)
2509{
2510 const BYTE* pdata = data;
2511 for (size_t x = 0; x < length; x++)
2512 {
2513 BYTE val = pdata[x];
2514 if (!WINPR_JSON_AddItemToArray(array, WINPR_JSON_CreateNumber(val)))
2515 return FALSE;
2516 }
2517 return TRUE;
2518}
2519
2520static BOOL fill_uint32_array(WINPR_JSON* array, const uint32_t* data, size_t length)
2521{
2522 for (size_t x = 0; x < length; x++)
2523 {
2524 uint32_t val = data[x];
2525 if (!WINPR_JSON_AddItemToArray(array, WINPR_JSON_CreateNumber(val)))
2526 return FALSE;
2527 }
2528 return TRUE;
2529}
2530
2531static WINPR_JSON* json_from_addin_item(const ADDIN_ARGV* val)
2532{
2533 WINPR_JSON* obj = WINPR_JSON_CreateObject();
2534 if (!obj)
2535 goto fail;
2536
2537 if (val)
2538 {
2539 if (!WINPR_JSON_AddNumberToObject(obj, "argc", val->argc))
2540 goto fail;
2541
2542 WINPR_JSON* array = WINPR_JSON_AddArrayToObject(obj, "argv");
2543 if (!array)
2544 goto fail;
2545 for (int x = 0; x < val->argc; x++)
2546 {
2547 const char* str = val->argv[x];
2548
2549 WINPR_JSON* item = NULL;
2550 if (!str)
2551 {
2552 item = WINPR_JSON_CreateNull();
2553 }
2554 else
2555 {
2556 item = WINPR_JSON_CreateString(str);
2557 }
2558
2559 if (!WINPR_JSON_AddItemToArray(array, item))
2560 goto fail;
2561 }
2562 }
2563 return obj;
2564
2565fail:
2566 WINPR_JSON_Delete(obj);
2567 return NULL;
2568}
2569
2570static BOOL json_from_addin_item_array(WINPR_JSON* json, const rdpSettings* settings,
2571 FreeRDP_Settings_Keys_Pointer key, size_t count)
2572{
2573 if (!json)
2574 return FALSE;
2575
2576 for (uint32_t x = 0; x < count; x++)
2577 {
2578 const ADDIN_ARGV* cval = freerdp_settings_get_pointer_array(settings, key, x);
2579 if (!WINPR_JSON_AddItemToArray(json, json_from_addin_item(cval)))
2580 return FALSE;
2581 }
2582 return TRUE;
2583}
2584
2585static BOOL add_string_or_null(WINPR_JSON* json, const char* key, const char* value)
2586{
2587 if (value)
2588 return WINPR_JSON_AddStringToObject(json, key, value) != NULL;
2589
2590 (void)WINPR_JSON_AddNullToObject(json, key);
2591 return TRUE;
2592}
2593
2594static WINPR_JSON* json_from_device_item(const RDPDR_DEVICE* val)
2595{
2596 WINPR_JSON* obj = WINPR_JSON_CreateObject();
2597 if (!obj)
2598 goto fail;
2599
2600 if (val)
2601 {
2602 union
2603 {
2604 const RDPDR_DEVICE* base;
2605 const RDPDR_PARALLEL* parallel;
2606 const RDPDR_SERIAL* serial;
2607 const RDPDR_SMARTCARD* smartcard;
2608 const RDPDR_PRINTER* printer;
2609 const RDPDR_DRIVE* drive;
2610 const RDPDR_DEVICE* device;
2611 } device;
2612
2613 device.base = val;
2614
2615 if (!WINPR_JSON_AddNumberToObject(obj, "Id", val->Id))
2616 goto fail;
2617 if (!WINPR_JSON_AddNumberToObject(obj, "Type", val->Type))
2618 goto fail;
2619 if (!add_string_or_null(obj, "Name", val->Name))
2620 goto fail;
2621 switch (val->Type)
2622 {
2623 case RDPDR_DTYP_SERIAL:
2624 if (!add_string_or_null(obj, "Path", device.serial->Path))
2625 goto fail;
2626 if (!add_string_or_null(obj, "Driver", device.serial->Driver))
2627 goto fail;
2628 if (!add_string_or_null(obj, "Permissive", device.serial->Permissive))
2629 goto fail;
2630 break;
2631 case RDPDR_DTYP_PARALLEL:
2632 if (!add_string_or_null(obj, "Path", device.parallel->Path))
2633 goto fail;
2634 break;
2635 case RDPDR_DTYP_PRINT:
2636 if (!add_string_or_null(obj, "DriverName", device.printer->DriverName))
2637 goto fail;
2638 if (!WINPR_JSON_AddBoolToObject(obj, "IsDefault", device.printer->IsDefault))
2639 goto fail;
2640 break;
2641 case RDPDR_DTYP_FILESYSTEM:
2642 if (!add_string_or_null(obj, "Path", device.drive->Path))
2643 goto fail;
2644 if (!WINPR_JSON_AddBoolToObject(obj, "IsDefault", device.drive->automount))
2645 goto fail;
2646 break;
2647 case RDPDR_DTYP_SMARTCARD:
2648 default:
2649 break;
2650 }
2651 }
2652 return obj;
2653
2654fail:
2655 WINPR_JSON_Delete(obj);
2656 return NULL;
2657}
2658
2659static BOOL json_from_device_item_array(WINPR_JSON* json, const rdpSettings* settings,
2660 FreeRDP_Settings_Keys_Pointer key, size_t count)
2661{
2662 if (!json)
2663 return FALSE;
2664
2665 for (uint32_t x = 0; x < count; x++)
2666 {
2667 const RDPDR_DEVICE* cval = freerdp_settings_get_pointer_array(settings, key, x);
2668 if (!WINPR_JSON_AddItemToArray(json, json_from_device_item(cval)))
2669 return FALSE;
2670 }
2671 return TRUE;
2672}
2673
2674static BOOL string_array_to_json(WINPR_JSON* json, const rdpSettings* settings, uint32_t argc,
2675 FreeRDP_Settings_Keys_Pointer key)
2676{
2677 for (uint32_t x = 0; x < argc; x++)
2678 {
2679 const char* cval = freerdp_settings_get_pointer_array(settings, key, x);
2680
2681 WINPR_JSON* item = NULL;
2682 if (!cval)
2683 item = WINPR_JSON_CreateNull();
2684 else
2685 item = WINPR_JSON_CreateString(cval);
2686 if (!WINPR_JSON_AddItemToArray(json, item))
2687 return FALSE;
2688 }
2689 return TRUE;
2690}
2691
2692static BOOL wchar_to_json(WINPR_JSON* obj, const char* key, const WCHAR* wstr, size_t len)
2693{
2694 if (len == 0)
2695 return WINPR_JSON_AddStringToObject(obj, key, "") != NULL;
2696
2697 const size_t slen = len * 6;
2698 char* str = calloc(1, slen);
2699 if (!str)
2700 return FALSE;
2701
2702 WINPR_JSON* jstr = NULL;
2703 SSIZE_T rc = ConvertWCharNToUtf8(wstr, len, str, slen);
2704 if (rc >= 0)
2705 jstr = WINPR_JSON_AddStringToObject(obj, key, str);
2706 free(str);
2707 return jstr != NULL;
2708}
2709
2710static BOOL wchar_from_json(WCHAR* wstr, size_t len, const WINPR_JSON* obj, const char* key)
2711{
2712 if (!obj || !WINPR_JSON_IsObject(obj))
2713 return FALSE;
2714 WINPR_JSON* item = WINPR_JSON_GetObjectItem(obj, key);
2715 if (!item || !WINPR_JSON_IsString(item))
2716 return FALSE;
2717
2718 const char* str = WINPR_JSON_GetStringValue(item);
2719 if (!str)
2720 {
2721 memset(wstr, 0, sizeof(WCHAR) * len);
2722 return TRUE;
2723 }
2724
2725 SSIZE_T rc = ConvertUtf8ToWChar(str, wstr, len);
2726 return rc >= 0;
2727}
2728
2729static int64_t int_from_json_item(const WINPR_JSON* item, int64_t min, int64_t max)
2730{
2731 if (!item || !WINPR_JSON_IsNumber(item))
2732 {
2733 errno = EINVAL;
2734 return 0;
2735 }
2736
2737 const double val = WINPR_JSON_GetNumberValue(item);
2738 if (isinf(val) || isnan(val))
2739 {
2740 errno = ERANGE;
2741 return 0;
2742 }
2743
2744 const int64_t ival = (int64_t)val;
2745 if ((ival < min) || (ival > max))
2746 {
2747 errno = ERANGE;
2748 return 0;
2749 }
2750
2751 return ival;
2752}
2753
2754static int64_t int_from_json(const WINPR_JSON* obj, const char* key, int64_t min, int64_t max)
2755{
2756 if (!obj || !WINPR_JSON_IsObject(obj))
2757 {
2758 errno = EINVAL;
2759 return 0;
2760 }
2761 WINPR_JSON* item = WINPR_JSON_GetObjectItem(obj, key);
2762 return int_from_json_item(item, min, max);
2763}
2764
2765static uint64_t uint_from_json_item(const WINPR_JSON* item, uint64_t max)
2766{
2767 if (!item || !WINPR_JSON_IsNumber(item))
2768 {
2769 errno = EINVAL;
2770 return 0;
2771 }
2772
2773 const double val = WINPR_JSON_GetNumberValue(item);
2774 if (isinf(val) || isnan(val) || (val < 0.0))
2775 {
2776 errno = ERANGE;
2777 return 0;
2778 }
2779
2780 const uint64_t uval = (uint64_t)val;
2781 if (uval > max)
2782 {
2783 errno = ERANGE;
2784 return 0;
2785 }
2786 return uval;
2787}
2788
2789static uint64_t uint_from_json(const WINPR_JSON* obj, const char* key, uint64_t max)
2790{
2791 if (!obj || !WINPR_JSON_IsObject(obj))
2792 {
2793 errno = EINVAL;
2794 return 0;
2795 }
2796
2797 WINPR_JSON* item = WINPR_JSON_GetObjectItem(obj, key);
2798 return uint_from_json_item(item, max);
2799}
2800
2801static WINPR_JSON* systemtime_to_json(WINPR_JSON* parent, const char* key, const SYSTEMTIME* st)
2802{
2803 WINPR_ASSERT(st);
2804
2805 WINPR_JSON* obj = WINPR_JSON_AddObjectToObject(parent, key);
2806 if (!obj)
2807 return NULL;
2808
2809 if (!WINPR_JSON_AddNumberToObject(obj, "wYear", st->wYear))
2810 goto fail;
2811 if (!WINPR_JSON_AddNumberToObject(obj, "wMonth", st->wMonth))
2812 goto fail;
2813 if (!WINPR_JSON_AddNumberToObject(obj, "wDayOfWeek", st->wDayOfWeek))
2814 goto fail;
2815 if (!WINPR_JSON_AddNumberToObject(obj, "wDay", st->wDay))
2816 goto fail;
2817 if (!WINPR_JSON_AddNumberToObject(obj, "wHour", st->wHour))
2818 goto fail;
2819 if (!WINPR_JSON_AddNumberToObject(obj, "wMinute", st->wMinute))
2820 goto fail;
2821 if (!WINPR_JSON_AddNumberToObject(obj, "wSecond", st->wSecond))
2822 goto fail;
2823 if (!WINPR_JSON_AddNumberToObject(obj, "wMilliseconds", st->wMilliseconds))
2824 goto fail;
2825
2826 return obj;
2827fail:
2828 WINPR_JSON_Delete(obj);
2829 return NULL;
2830}
2831
2832static BOOL systemtime_from_json(const WINPR_JSON* pobj, const char* key, SYSTEMTIME* st)
2833{
2834 WINPR_ASSERT(st);
2835
2836 if (!pobj || !WINPR_JSON_IsObject(pobj))
2837 return FALSE;
2838
2839 WINPR_JSON* obj = WINPR_JSON_GetObjectItem(pobj, key);
2840 if (!obj || !WINPR_JSON_IsObject(obj))
2841 return FALSE;
2842
2843 errno = 0;
2844 st->wYear = (uint16_t)uint_from_json(obj, "wYear", UINT16_MAX);
2845 st->wMonth = (uint16_t)uint_from_json(obj, "wMonth", UINT16_MAX);
2846 st->wDayOfWeek = (uint16_t)uint_from_json(obj, "wDayOfWeek", UINT16_MAX);
2847 st->wDay = (uint16_t)uint_from_json(obj, "wDay", UINT16_MAX);
2848 st->wHour = (uint16_t)uint_from_json(obj, "wHour", UINT16_MAX);
2849 st->wMinute = (uint16_t)uint_from_json(obj, "wMinute", UINT16_MAX);
2850 st->wSecond = (uint16_t)uint_from_json(obj, "wSecond", UINT16_MAX);
2851 st->wMilliseconds = (uint16_t)uint_from_json(obj, "wMilliseconds", UINT16_MAX);
2852 return errno == 0;
2853}
2854
2855static BOOL ts_info_from_json(TIME_ZONE_INFORMATION* tz, const WINPR_JSON* json)
2856{
2857 WINPR_ASSERT(tz);
2858
2859 if (!json || !WINPR_JSON_IsObject(json))
2860 return FALSE;
2861
2862 errno = 0;
2863 tz->Bias = (int32_t)int_from_json(json, "Bias", INT32_MIN, INT32_MAX);
2864 tz->StandardBias = (int32_t)int_from_json(json, "StandardBias", INT32_MIN, INT32_MAX);
2865 tz->DaylightBias = (int32_t)int_from_json(json, "DaylightBias", INT32_MIN, INT32_MAX);
2866 if (errno != 0)
2867 return FALSE;
2868
2869 if (!systemtime_from_json(json, "StandardDate", &tz->StandardDate))
2870 return FALSE;
2871 if (!systemtime_from_json(json, "DaylightDate", &tz->DaylightDate))
2872 return FALSE;
2873
2874 if (!wchar_from_json(tz->StandardName, ARRAYSIZE(tz->StandardName), json, "StandardName"))
2875 return FALSE;
2876 if (!wchar_from_json(tz->DaylightName, ARRAYSIZE(tz->DaylightName), json, "DaylightName"))
2877 return FALSE;
2878
2879 return TRUE;
2880}
2881
2882static BOOL ts_info_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer key,
2883 const WINPR_JSON* json)
2884{
2885 if (!json || !WINPR_JSON_IsArray(json))
2886 return FALSE;
2887
2888 const size_t count = WINPR_JSON_GetArraySize(json);
2889 if (!freerdp_settings_set_pointer_len(settings, key, NULL, count))
2890 return FALSE;
2891
2892 for (size_t x = 0; x < count; x++)
2893 {
2894 TIME_ZONE_INFORMATION* tz = freerdp_settings_get_pointer_array_writable(settings, key, x);
2895 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
2896 if (!ts_info_from_json(tz, obj))
2897 return FALSE;
2898 }
2899 return TRUE;
2900}
2901
2902static BOOL tz_info_to_json(WINPR_JSON* json, const TIME_ZONE_INFORMATION* ptz)
2903{
2904 WINPR_JSON* obj = WINPR_JSON_CreateObject();
2905 if (!obj)
2906 return FALSE;
2907 if (!WINPR_JSON_AddItemToArray(json, obj))
2908 return FALSE;
2909
2910 TIME_ZONE_INFORMATION tz = { 0 };
2911 if (ptz)
2912 tz = *ptz;
2913
2914 if (!WINPR_JSON_AddNumberToObject(obj, "Bias", tz.Bias))
2915 return FALSE;
2916
2917 if (!wchar_to_json(obj, "StandardName", tz.StandardName, ARRAYSIZE(tz.StandardName)))
2918 return FALSE;
2919
2920 if (!systemtime_to_json(obj, "StandardDate", &tz.StandardDate))
2921 return FALSE;
2922
2923 if (!WINPR_JSON_AddNumberToObject(obj, "StandardBias", tz.Bias))
2924 return FALSE;
2925
2926 if (!wchar_to_json(obj, "DaylightName", tz.DaylightName, ARRAYSIZE(tz.DaylightName)))
2927 return FALSE;
2928
2929 if (!systemtime_to_json(obj, "DaylightDate", &tz.DaylightDate))
2930 return FALSE;
2931
2932 if (!WINPR_JSON_AddNumberToObject(obj, "DaylightBias", tz.Bias))
2933 return FALSE;
2934 return TRUE;
2935}
2936
2937static BOOL glyph_cache_def_to_json(WINPR_JSON* json, const GLYPH_CACHE_DEFINITION* def)
2938{
2939 WINPR_ASSERT(def);
2940 if (!json || !WINPR_JSON_IsArray(json))
2941 return FALSE;
2942
2943 WINPR_JSON* obj = WINPR_JSON_CreateObject();
2944 if (!obj)
2945 return FALSE;
2946 if (!WINPR_JSON_AddItemToArray(json, obj))
2947 return FALSE;
2948
2949 if (!WINPR_JSON_AddNumberToObject(obj, "cacheEntries", def->cacheEntries))
2950 return FALSE;
2951 if (!WINPR_JSON_AddNumberToObject(obj, "cacheMaximumCellSize", def->cacheMaximumCellSize))
2952 return FALSE;
2953 return TRUE;
2954}
2955
2956static BOOL glyph_cache_def_array_to_json(WINPR_JSON* json, const GLYPH_CACHE_DEFINITION* def,
2957 size_t count)
2958{
2959 if (!json || !WINPR_JSON_IsArray(json))
2960 return FALSE;
2961
2962 for (size_t x = 0; x < count; x++)
2963 {
2964 if (!glyph_cache_def_to_json(json, &def[x]))
2965 return FALSE;
2966 }
2967 return TRUE;
2968}
2969
2970static BOOL glyph_cache_def_from_json(GLYPH_CACHE_DEFINITION* def, const WINPR_JSON* json)
2971{
2972 WINPR_ASSERT(def);
2973 WINPR_ASSERT(json);
2974
2975 if (!WINPR_JSON_IsObject(json))
2976 return FALSE;
2977
2978 errno = 0;
2979 def->cacheEntries = (uint16_t)uint_from_json(json, "cacheEntries", UINT16_MAX);
2980 def->cacheMaximumCellSize = (uint16_t)uint_from_json(json, "cacheMaximumCellSize", UINT16_MAX);
2981 return errno == 0;
2982}
2983
2984static BOOL glyph_cache_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
2985 const WINPR_JSON* json)
2986{
2987 if (!json || !WINPR_JSON_IsArray(json))
2988 return FALSE;
2989
2990 const size_t count = WINPR_JSON_GetArraySize(json);
2991 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
2992 return FALSE;
2993
2994 for (size_t x = 0; x < count; x++)
2995 {
2996 GLYPH_CACHE_DEFINITION* cache =
2997 freerdp_settings_get_pointer_array_writable(settings, id, x);
2998 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
2999 if (!glyph_cache_def_from_json(cache, obj))
3000 return FALSE;
3001 }
3002 return TRUE;
3003}
3004
3005static BOOL bitmap_cache_v2_from_json(BITMAP_CACHE_V2_CELL_INFO* info, const WINPR_JSON* json)
3006{
3007 WINPR_ASSERT(info);
3008
3009 if (!json || !WINPR_JSON_IsObject(json))
3010 return FALSE;
3011
3012 errno = 0;
3013 info->numEntries = (uint32_t)uint_from_json(json, "numEntries", UINT32_MAX);
3014 if (errno != 0)
3015 return FALSE;
3016
3017 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, "persistent");
3018 if (!item || !WINPR_JSON_IsBool(item))
3019 return FALSE;
3020
3021 info->persistent = WINPR_JSON_IsTrue(item);
3022 return TRUE;
3023}
3024
3025static BOOL bitmap_cache_v2_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
3026 const WINPR_JSON* json)
3027{
3028 if (!json || !WINPR_JSON_IsArray(json))
3029 return FALSE;
3030
3031 const size_t count = WINPR_JSON_GetArraySize(json);
3032 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
3033 return FALSE;
3034
3035 for (size_t x = 0; x < count; x++)
3036 {
3037 BITMAP_CACHE_V2_CELL_INFO* cache =
3038 freerdp_settings_get_pointer_array_writable(settings, id, x);
3039 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
3040 if (!bitmap_cache_v2_from_json(cache, obj))
3041 return FALSE;
3042 }
3043 return TRUE;
3044}
3045
3046static BOOL client_cookie_from_json(ARC_CS_PRIVATE_PACKET* cookie, const WINPR_JSON* json)
3047{
3048 WINPR_ASSERT(cookie);
3049 WINPR_ASSERT(json);
3050
3051 if (!WINPR_JSON_IsObject(json))
3052 return FALSE;
3053
3054 errno = 0;
3055 cookie->cbLen = (uint32_t)uint_from_json(json, "cbLen", UINT32_MAX);
3056 cookie->version = (uint32_t)uint_from_json(json, "version", UINT32_MAX);
3057 cookie->logonId = (uint32_t)uint_from_json(json, "logonId", UINT32_MAX);
3058 if (errno != 0)
3059 return FALSE;
3060
3061 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, "securityVerifier");
3062 if (!item || !WINPR_JSON_IsArray(item))
3063 return FALSE;
3064
3065 const size_t len = WINPR_JSON_GetArraySize(item);
3066 if (len != ARRAYSIZE(cookie->securityVerifier))
3067 return FALSE;
3068
3069 errno = 0;
3070 for (size_t x = 0; x < len; x++)
3071 {
3072 WINPR_JSON* citem = WINPR_JSON_GetArrayItem(item, x);
3073 const uint64_t val = uint_from_json_item(citem, UINT8_MAX);
3074 cookie->securityVerifier[x] = (uint8_t)val;
3075 }
3076 return errno == 0;
3077}
3078
3079static BOOL client_cookie_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
3080 const WINPR_JSON* json)
3081{
3082 if (!json || !WINPR_JSON_IsArray(json))
3083 return FALSE;
3084
3085 const size_t count = WINPR_JSON_GetArraySize(json);
3086 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
3087 return FALSE;
3088
3089 for (size_t x = 0; x < count; x++)
3090 {
3091 ARC_CS_PRIVATE_PACKET* cache = freerdp_settings_get_pointer_array_writable(settings, id, x);
3092 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
3093 if (!client_cookie_from_json(cache, obj))
3094 return FALSE;
3095 }
3096 return TRUE;
3097}
3098
3099static BOOL server_cookie_from_json(ARC_SC_PRIVATE_PACKET* cookie, const WINPR_JSON* json)
3100{
3101 WINPR_ASSERT(cookie);
3102
3103 if (!json || !WINPR_JSON_IsObject(json))
3104 return FALSE;
3105
3106 errno = 0;
3107 cookie->cbLen = (uint32_t)uint_from_json(json, "cbLen", UINT32_MAX);
3108 cookie->version = (uint32_t)uint_from_json(json, "version", UINT32_MAX);
3109 cookie->logonId = (uint32_t)uint_from_json(json, "logonId", UINT32_MAX);
3110 if (errno != 0)
3111 return FALSE;
3112
3113 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, "arcRandomBits");
3114 if (!item || !WINPR_JSON_IsArray(item))
3115 return FALSE;
3116
3117 const size_t len = WINPR_JSON_GetArraySize(item);
3118 if (len != ARRAYSIZE(cookie->arcRandomBits))
3119 return FALSE;
3120
3121 errno = 0;
3122 for (size_t x = 0; x < len; x++)
3123 {
3124 WINPR_JSON* citem = WINPR_JSON_GetArrayItem(item, x);
3125 cookie->arcRandomBits[x] = (uint8_t)uint_from_json_item(citem, UINT8_MAX);
3126 }
3127 return errno == 0;
3128}
3129
3130static BOOL server_cookie_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
3131 const WINPR_JSON* json)
3132{
3133 if (!json || !WINPR_JSON_IsArray(json))
3134 return FALSE;
3135
3136 const size_t count = WINPR_JSON_GetArraySize(json);
3137 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
3138 return FALSE;
3139
3140 for (size_t x = 0; x < count; x++)
3141 {
3142 ARC_SC_PRIVATE_PACKET* cache = freerdp_settings_get_pointer_array_writable(settings, id, x);
3143 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
3144 if (!server_cookie_from_json(cache, obj))
3145 return FALSE;
3146 }
3147 return TRUE;
3148}
3149
3150static BOOL channel_def_from_json(CHANNEL_DEF* cookie, const WINPR_JSON* json)
3151{
3152 WINPR_ASSERT(cookie);
3153 WINPR_ASSERT(json);
3154
3155 if (!WINPR_JSON_IsObject(json))
3156 return FALSE;
3157
3158 errno = 0;
3159 cookie->options = (uint32_t)uint_from_json(json, "options", UINT32_MAX);
3160 if (errno != 0)
3161 return FALSE;
3162
3163 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, "name");
3164 if (!item || !WINPR_JSON_IsString(item))
3165 return FALSE;
3166
3167 const char* str = WINPR_JSON_GetStringValue(item);
3168 if (!str)
3169 memset(cookie->name, 0, sizeof(cookie->name));
3170 else
3171 {
3172 strncpy(cookie->name, str, strnlen(str, ARRAYSIZE(cookie->name)));
3173 }
3174 return TRUE;
3175}
3176
3177static BOOL channel_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
3178 const WINPR_JSON* json)
3179{
3180 if (!json || !WINPR_JSON_IsArray(json))
3181 return FALSE;
3182
3183 const size_t count = WINPR_JSON_GetArraySize(json);
3184 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
3185 return FALSE;
3186
3187 for (size_t x = 0; x < count; x++)
3188 {
3189 CHANNEL_DEF* cache = freerdp_settings_get_pointer_array_writable(settings, id, x);
3190 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
3191 if (!channel_def_from_json(cache, obj))
3192 return FALSE;
3193 }
3194 return TRUE;
3195}
3196
3197static BOOL monitor_attributes_from_json(MONITOR_ATTRIBUTES* attributes, const WINPR_JSON* json)
3198{
3199 WINPR_ASSERT(attributes);
3200 if (!json || !WINPR_JSON_IsObject(json))
3201 return FALSE;
3202
3203 WINPR_JSON* obj = WINPR_JSON_GetObjectItem(json, "attributes");
3204 if (!obj || !WINPR_JSON_IsObject(obj))
3205 return FALSE;
3206
3207 errno = 0;
3208 attributes->physicalWidth = (uint32_t)uint_from_json(obj, "physicalWidth", UINT32_MAX);
3209 attributes->physicalHeight = (uint32_t)uint_from_json(obj, "physicalHeight", UINT32_MAX);
3210 attributes->orientation = (uint32_t)uint_from_json(obj, "orientation", UINT32_MAX);
3211 attributes->desktopScaleFactor =
3212 (uint32_t)uint_from_json(obj, "desktopScaleFactor", UINT32_MAX);
3213 attributes->deviceScaleFactor = (uint32_t)uint_from_json(obj, "deviceScaleFactor", UINT32_MAX);
3214 return errno == 0;
3215}
3216
3217static BOOL monitor_def_from_json(rdpMonitor* monitor, const WINPR_JSON* json)
3218{
3219 WINPR_ASSERT(monitor);
3220
3221 if (!json || !WINPR_JSON_IsObject(json))
3222 return FALSE;
3223
3224 errno = 0;
3225 monitor->x = (int32_t)int_from_json(json, "x", INT32_MIN, INT32_MAX);
3226 monitor->y = (int32_t)int_from_json(json, "y", INT32_MIN, INT32_MAX);
3227 monitor->width = (int32_t)int_from_json(json, "width", 0, INT32_MAX);
3228 monitor->height = (int32_t)int_from_json(json, "height", 0, INT32_MAX);
3229 monitor->orig_screen = (uint32_t)uint_from_json(json, "orig_screen", UINT32_MAX);
3230 if (errno != 0)
3231 return FALSE;
3232
3233 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, "is_primary");
3234 if (!item)
3235 return FALSE;
3236 if (!WINPR_JSON_IsBool(item))
3237 return FALSE;
3238 monitor->is_primary = WINPR_JSON_IsTrue(item) ? 1 : 0;
3239
3240 return monitor_attributes_from_json(&monitor->attributes, json);
3241}
3242
3243static BOOL monitor_def_array_from_json(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer id,
3244 const WINPR_JSON* json)
3245{
3246 if (!json || !WINPR_JSON_IsArray(json))
3247 return FALSE;
3248
3249 const size_t count = WINPR_JSON_GetArraySize(json);
3250 if (!freerdp_settings_set_pointer_len(settings, id, NULL, count))
3251 return FALSE;
3252
3253 for (size_t x = 0; x < count; x++)
3254 {
3255 rdpMonitor* cache = freerdp_settings_get_pointer_array_writable(settings, id, x);
3256 WINPR_JSON* obj = WINPR_JSON_GetArrayItem(json, x);
3257 if (!monitor_def_from_json(cache, obj))
3258 return FALSE;
3259 }
3260 return TRUE;
3261}
3262
3263static BOOL client_cookie_to_json(WINPR_JSON* json, const ARC_CS_PRIVATE_PACKET* cs)
3264{
3265 WINPR_JSON* obj = WINPR_JSON_CreateObject();
3266 if (!obj)
3267 return FALSE;
3268 if (!WINPR_JSON_AddItemToArray(json, obj))
3269 return FALSE;
3270
3271 if (!WINPR_JSON_AddNumberToObject(obj, "cbLen", cs->cbLen))
3272 return FALSE;
3273 if (!WINPR_JSON_AddNumberToObject(obj, "version", cs->version))
3274 return FALSE;
3275 if (!WINPR_JSON_AddNumberToObject(obj, "logonId", cs->logonId))
3276 return FALSE;
3277 WINPR_JSON* array = WINPR_JSON_AddArrayToObject(obj, "securityVerifier");
3278 if (!array)
3279 return FALSE;
3280
3281 for (size_t x = 0; x < ARRAYSIZE(cs->securityVerifier); x++)
3282 {
3283 WINPR_JSON* item = WINPR_JSON_CreateNumber(cs->securityVerifier[x]);
3284 if (!item)
3285 return FALSE;
3286 if (!WINPR_JSON_AddItemToArray(array, item))
3287 return FALSE;
3288 }
3289 return TRUE;
3290}
3291
3292static BOOL client_cookie_array_to_json(WINPR_JSON* json, const ARC_CS_PRIVATE_PACKET* cs,
3293 size_t count)
3294{
3295 for (size_t x = 0; x < count; x++)
3296 {
3297 if (!client_cookie_to_json(json, &cs[x]))
3298 return FALSE;
3299 }
3300 return TRUE;
3301}
3302
3303static BOOL server_cookie_to_json(WINPR_JSON* json, const ARC_SC_PRIVATE_PACKET* cs)
3304{
3305 WINPR_JSON* obj = WINPR_JSON_CreateObject();
3306 if (!obj)
3307 return FALSE;
3308 if (!WINPR_JSON_AddItemToArray(json, obj))
3309 return FALSE;
3310
3311 if (!WINPR_JSON_AddNumberToObject(obj, "cbLen", cs->cbLen))
3312 return FALSE;
3313 if (!WINPR_JSON_AddNumberToObject(obj, "version", cs->version))
3314 return FALSE;
3315 if (!WINPR_JSON_AddNumberToObject(obj, "logonId", cs->logonId))
3316 return FALSE;
3317 WINPR_JSON* array = WINPR_JSON_AddArrayToObject(obj, "arcRandomBits");
3318 if (!array)
3319 return FALSE;
3320
3321 for (size_t x = 0; x < ARRAYSIZE(cs->arcRandomBits); x++)
3322 {
3323 WINPR_JSON* item = WINPR_JSON_CreateNumber(cs->arcRandomBits[x]);
3324 if (!item)
3325 return FALSE;
3326 if (!WINPR_JSON_AddItemToArray(array, item))
3327 return FALSE;
3328 }
3329 return TRUE;
3330}
3331
3332static BOOL server_cookie_array_to_json(WINPR_JSON* json, const ARC_SC_PRIVATE_PACKET* cs,
3333 size_t count)
3334{
3335 for (size_t x = 0; x < count; x++)
3336 {
3337 if (!server_cookie_to_json(json, &cs[x]))
3338 return FALSE;
3339 }
3340 return TRUE;
3341}
3342
3343static BOOL bitmap_cache_v2_to_json(WINPR_JSON* json, const BITMAP_CACHE_V2_CELL_INFO* info)
3344{
3345 WINPR_JSON* obj = WINPR_JSON_CreateObject();
3346 if (!obj)
3347 return FALSE;
3348 if (!WINPR_JSON_AddItemToArray(json, obj))
3349 return FALSE;
3350
3351 if (!WINPR_JSON_AddNumberToObject(obj, "numEntries", info->numEntries))
3352 return FALSE;
3353 if (!WINPR_JSON_AddBoolToObject(obj, "persistent", info->persistent))
3354 return FALSE;
3355 return TRUE;
3356}
3357
3358static BOOL bitmap_cache_v2_array_to_json(WINPR_JSON* json, const BITMAP_CACHE_V2_CELL_INFO* info,
3359 size_t count)
3360{
3361 for (size_t x = 0; x < count; x++)
3362 {
3363 if (!bitmap_cache_v2_to_json(json, &info[x]))
3364 return FALSE;
3365 }
3366 return TRUE;
3367}
3368
3369static BOOL monitor_attributes_to_json(WINPR_JSON* pobj, const MONITOR_ATTRIBUTES* attributes)
3370{
3371 WINPR_ASSERT(attributes);
3372 WINPR_JSON* obj = WINPR_JSON_AddObjectToObject(pobj, "attributes");
3373 if (!obj)
3374 return FALSE;
3375 if (!WINPR_JSON_AddNumberToObject(obj, "physicalWidth", attributes->physicalWidth))
3376 return FALSE;
3377 if (!WINPR_JSON_AddNumberToObject(obj, "physicalHeight", attributes->physicalHeight))
3378 return FALSE;
3379 if (!WINPR_JSON_AddNumberToObject(obj, "orientation", attributes->orientation))
3380 return FALSE;
3381 if (!WINPR_JSON_AddNumberToObject(obj, "desktopScaleFactor", attributes->desktopScaleFactor))
3382 return FALSE;
3383 if (!WINPR_JSON_AddNumberToObject(obj, "deviceScaleFactor", attributes->deviceScaleFactor))
3384 return FALSE;
3385 return TRUE;
3386}
3387
3388static BOOL monitor_def_to_json(WINPR_JSON* json, const rdpMonitor* monitor)
3389{
3390 WINPR_ASSERT(monitor);
3391 WINPR_JSON* obj = WINPR_JSON_CreateObject();
3392 if (!obj)
3393 return FALSE;
3394 if (!WINPR_JSON_AddItemToArray(json, obj))
3395 return FALSE;
3396
3397 if (!WINPR_JSON_AddNumberToObject(obj, "x", monitor->x))
3398 return FALSE;
3399 if (!WINPR_JSON_AddNumberToObject(obj, "y", monitor->y))
3400 return FALSE;
3401 if (!WINPR_JSON_AddNumberToObject(obj, "width", monitor->width))
3402 return FALSE;
3403 if (!WINPR_JSON_AddNumberToObject(obj, "height", monitor->height))
3404 return FALSE;
3405 if (!WINPR_JSON_AddBoolToObject(obj, "is_primary", monitor->is_primary != 0))
3406 return FALSE;
3407 if (!WINPR_JSON_AddNumberToObject(obj, "orig_screen", monitor->orig_screen))
3408 return FALSE;
3409 return monitor_attributes_to_json(obj, &monitor->attributes);
3410}
3411
3412static BOOL monitor_def_array_to_json(WINPR_JSON* json, const rdpMonitor* monitors, size_t count)
3413{
3414 for (size_t x = 0; x < count; x++)
3415 {
3416 if (!monitor_def_to_json(json, &monitors[x]))
3417 return FALSE;
3418 }
3419 return TRUE;
3420}
3421
3422static BOOL channel_def_to_json(WINPR_JSON* json, const CHANNEL_DEF* channel)
3423{
3424 WINPR_ASSERT(channel);
3425 WINPR_JSON* obj = WINPR_JSON_CreateObject();
3426 if (!obj)
3427 return FALSE;
3428 if (!WINPR_JSON_AddItemToArray(json, obj))
3429 return FALSE;
3430
3431 if (!WINPR_JSON_AddStringToObject(obj, "name", channel->name))
3432 return FALSE;
3433 if (!WINPR_JSON_AddNumberToObject(obj, "options", channel->options))
3434 return FALSE;
3435 return TRUE;
3436}
3437
3438static BOOL channel_def_array_to_json(WINPR_JSON* json, const CHANNEL_DEF* channels, size_t count)
3439{
3440 for (size_t x = 0; x < count; x++)
3441 {
3442 if (!channel_def_to_json(json, &channels[x]))
3443 return FALSE;
3444 }
3445 return TRUE;
3446}
3447
3448static BOOL serialize_pointer(const rdpSettings* settings, WINPR_JSON* json,
3449 FreeRDP_Settings_Keys_Pointer id)
3450{
3451 const char* name = freerdp_settings_get_name_for_key(id);
3452 if (!name)
3453 return FALSE;
3454
3455 WINPR_JSON* jval = WINPR_JSON_AddArrayToObject(json, name);
3456 if (!jval)
3457 return FALSE;
3458
3459 const void* val = freerdp_settings_get_pointer(settings, id);
3460 if (!val)
3461 return TRUE;
3462
3463 switch (id)
3464 {
3465 case FreeRDP_instance:
3466 {
3467 union
3468 {
3469 const void* v;
3470 uintptr_t u;
3471 } ptr;
3472
3473 ptr.v = val;
3474 return fill_array(jval, &ptr.u, sizeof(ptr.u));
3475 }
3476 case FreeRDP_ServerRandom:
3477 {
3478 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_ServerRandomLength);
3479 return fill_array(jval, val, len);
3480 }
3481 case FreeRDP_ServerCertificate:
3482 {
3483 const uint32_t len =
3484 freerdp_settings_get_uint32(settings, FreeRDP_ServerCertificateLength);
3485 return fill_array(jval, val, len);
3486 }
3487 case FreeRDP_ClientRandom:
3488 {
3489 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_ClientRandomLength);
3490 return fill_array(jval, val, len);
3491 }
3492 case FreeRDP_ServerLicenseProductIssuers:
3493 {
3494 const uint32_t len =
3495 freerdp_settings_get_uint32(settings, FreeRDP_ServerLicenseProductIssuersCount);
3496 return string_array_to_json(jval, settings, len, FreeRDP_ServerLicenseProductIssuers);
3497 }
3498 case FreeRDP_RedirectionPassword:
3499 {
3500 const uint32_t len =
3501 freerdp_settings_get_uint32(settings, FreeRDP_RedirectionPasswordLength);
3502 return fill_array(jval, val, len);
3503 }
3504 case FreeRDP_RedirectionGuid:
3505 {
3506 const uint32_t len =
3507 freerdp_settings_get_uint32(settings, FreeRDP_RedirectionGuidLength);
3508 return fill_array(jval, val, len);
3509 }
3510 case FreeRDP_LoadBalanceInfo:
3511 {
3512 const uint32_t len =
3513 freerdp_settings_get_uint32(settings, FreeRDP_LoadBalanceInfoLength);
3514 return fill_array(jval, val, len);
3515 }
3516 case FreeRDP_ClientTimeZone:
3517 {
3518 return tz_info_to_json(jval, val);
3519 }
3520 case FreeRDP_RedirectionTsvUrl:
3521 {
3522 const uint32_t len =
3523 freerdp_settings_get_uint32(settings, FreeRDP_RedirectionTsvUrlLength);
3524 return fill_array(jval, val, len);
3525 }
3526 case FreeRDP_GlyphCache:
3527 {
3528 return glyph_cache_def_array_to_json(jval, val, val ? 10 : 0);
3529 }
3530 case FreeRDP_FragCache:
3531 {
3532 return glyph_cache_def_array_to_json(jval, val, val ? 1 : 0);
3533 }
3534 case FreeRDP_BitmapCacheV2CellInfo:
3535 {
3536 const uint32_t len =
3537 freerdp_settings_get_uint32(settings, FreeRDP_BitmapCacheV2NumCells);
3538 return bitmap_cache_v2_array_to_json(jval, val, len);
3539 }
3540 case FreeRDP_OrderSupport:
3541 {
3542 const uint32_t len = 32;
3543 return fill_array(jval, val, len);
3544 }
3545 case FreeRDP_ClientAutoReconnectCookie:
3546 {
3547 return client_cookie_array_to_json(jval, val, 1);
3548 }
3549 case FreeRDP_ServerAutoReconnectCookie:
3550 {
3551 return server_cookie_array_to_json(jval, val, 1);
3552 }
3553 case FreeRDP_Password51:
3554 {
3555 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_Password51Length);
3556 return fill_array(jval, val, len);
3557 }
3558 case FreeRDP_ReceivedCapabilities:
3559 {
3560 const uint32_t len =
3561 freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
3562 return fill_array(jval, val, len);
3563 }
3564 case FreeRDP_MonitorIds:
3565 {
3566 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
3567 return fill_uint32_array(jval, val, len);
3568 }
3569 case FreeRDP_TargetNetPorts:
3570 {
3571 const uint32_t len =
3572 freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
3573 return fill_uint32_array(jval, val, len);
3574 }
3575 case FreeRDP_MonitorDefArray:
3576 {
3577 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_MonitorDefArraySize);
3578 return monitor_def_array_to_json(jval, val, len);
3579 }
3580 case FreeRDP_ChannelDefArray:
3581 {
3582 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_ChannelDefArraySize);
3583 return channel_def_array_to_json(jval, val, len);
3584 }
3585 case FreeRDP_ReceivedCapabilityDataSizes:
3586 {
3587 const uint32_t len =
3588 freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
3589 return fill_uint32_array(jval, val, len);
3590 }
3591 case FreeRDP_ReceivedCapabilityData:
3592 {
3593 const uint32_t len =
3594 freerdp_settings_get_uint32(settings, FreeRDP_ReceivedCapabilitiesSize);
3595 const UINT32* pclen =
3596 freerdp_settings_get_pointer(settings, FreeRDP_ReceivedCapabilityDataSizes);
3597 if (!pclen)
3598 return FALSE;
3599
3600 for (uint32_t x = 0; x < len; x++)
3601 {
3602 const char* cval = freerdp_settings_get_pointer_array(settings, id, x);
3603
3604 WINPR_JSON* item = WINPR_JSON_CreateArray();
3605 if (!item)
3606 return FALSE;
3607 if (!WINPR_JSON_AddItemToArray(jval, item))
3608 return FALSE;
3609 if (!fill_array(item, cval, pclen[x]))
3610 return FALSE;
3611 }
3612 return TRUE;
3613 }
3614 case FreeRDP_TargetNetAddresses:
3615 {
3616 const uint32_t len =
3617 freerdp_settings_get_uint32(settings, FreeRDP_TargetNetAddressCount);
3618 return string_array_to_json(jval, settings, len, id);
3619 }
3620 case FreeRDP_RedirectionTargetCertificate:
3621 case FreeRDP_RdpServerCertificate:
3622 {
3623 WINPR_JSON* item = NULL;
3624 size_t len = 0;
3625 char* pem = freerdp_certificate_get_pem(val, &len);
3626 if (pem)
3627 item = WINPR_JSON_CreateString(pem);
3628 else if (val)
3629 item = WINPR_JSON_CreateString("");
3630 else
3631 item = WINPR_JSON_CreateNull();
3632 free(pem);
3633 if (!item)
3634 return TRUE;
3635
3636 return WINPR_JSON_AddItemToArray(jval, item);
3637 }
3638 case FreeRDP_RdpServerRsaKey:
3639 {
3640 WINPR_JSON* item = NULL;
3641 size_t len = 0;
3642 char* pem = freerdp_key_get_pem(val, &len, NULL);
3643 if (pem)
3644 item = WINPR_JSON_CreateString(pem);
3645 free(pem);
3646 if (!item)
3647 return TRUE;
3648
3649 return WINPR_JSON_AddItemToArray(jval, item);
3650 }
3651 case FreeRDP_DeviceArray:
3652 {
3653 const uint32_t len = freerdp_settings_get_uint32(settings, FreeRDP_DeviceArraySize);
3654 return json_from_device_item_array(jval, settings, id, len);
3655 }
3656 case FreeRDP_StaticChannelArray:
3657 {
3658 const uint32_t len =
3659 freerdp_settings_get_uint32(settings, FreeRDP_StaticChannelArraySize);
3660 return json_from_addin_item_array(jval, settings, id, len);
3661 }
3662 case FreeRDP_DynamicChannelArray:
3663 {
3664 const uint32_t len =
3665 freerdp_settings_get_uint32(settings, FreeRDP_DynamicChannelArraySize);
3666 return json_from_addin_item_array(jval, settings, id, len);
3667 }
3668 case FreeRDP_POINTER_UNUSED:
3669 default:
3670 return FALSE;
3671 }
3672}
3673
3674char* freerdp_settings_serialize(const rdpSettings* settings, BOOL pretty, size_t* plength)
3675{
3676 char* str = NULL;
3677
3678 if (plength)
3679 *plength = 0;
3680
3681 if (!settings)
3682 return NULL;
3683
3684 WINPR_JSON* json = WINPR_JSON_CreateObject();
3685 if (!json)
3686 return NULL;
3687
3688 WINPR_JSON* jbool = WINPR_JSON_AddObjectToObject(
3689 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_BOOL));
3690 if (!jbool)
3691 goto fail;
3692 WINPR_JSON* juint16 = WINPR_JSON_AddObjectToObject(
3693 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT16));
3694 if (!juint16)
3695 goto fail;
3696 WINPR_JSON* jint16 = WINPR_JSON_AddObjectToObject(
3697 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT16));
3698 if (!jint16)
3699 goto fail;
3700 WINPR_JSON* juint32 = WINPR_JSON_AddObjectToObject(
3701 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT32));
3702 if (!juint32)
3703 goto fail;
3704 WINPR_JSON* jint32 = WINPR_JSON_AddObjectToObject(
3705 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT32));
3706 if (!jint32)
3707 goto fail;
3708 WINPR_JSON* juint64 = WINPR_JSON_AddObjectToObject(
3709 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT64));
3710 if (!juint64)
3711 goto fail;
3712 WINPR_JSON* jint64 = WINPR_JSON_AddObjectToObject(
3713 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT64));
3714 if (!jint64)
3715 goto fail;
3716 WINPR_JSON* jstring = WINPR_JSON_AddObjectToObject(
3717 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_STRING));
3718 if (!jstring)
3719 goto fail;
3720 WINPR_JSON* jpointer = WINPR_JSON_AddObjectToObject(
3721 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_POINTER));
3722 if (!jpointer)
3723 goto fail;
3724
3725 for (int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
3726 {
3727 union
3728 {
3729
3730 int s;
3731 FreeRDP_Settings_Keys_Bool b;
3732 FreeRDP_Settings_Keys_Int16 i16;
3733 FreeRDP_Settings_Keys_UInt16 u16;
3734 FreeRDP_Settings_Keys_Int32 i32;
3735 FreeRDP_Settings_Keys_UInt32 u32;
3736 FreeRDP_Settings_Keys_Int64 i64;
3737 FreeRDP_Settings_Keys_UInt64 u64;
3738 FreeRDP_Settings_Keys_String str;
3739 FreeRDP_Settings_Keys_Pointer ptr;
3740 } iter;
3741 iter.s = x;
3742
3743 const char* name = freerdp_settings_get_name_for_key(iter.s);
3744 SSIZE_T type = freerdp_settings_get_type_for_key(iter.s);
3745 switch (type)
3746 {
3747 case RDP_SETTINGS_TYPE_BOOL:
3748 {
3749 const BOOL val = freerdp_settings_get_bool(settings, iter.b);
3750 if (!WINPR_JSON_AddBoolToObject(jbool, name, val))
3751 goto fail;
3752 }
3753 break;
3754 case RDP_SETTINGS_TYPE_UINT16:
3755 {
3756 const uint16_t val = freerdp_settings_get_uint16(settings, iter.u16);
3757 if (!WINPR_JSON_AddNumberToObject(juint16, name, (double)val))
3758 goto fail;
3759 }
3760 break;
3761 case RDP_SETTINGS_TYPE_INT16:
3762 {
3763 const int16_t val = freerdp_settings_get_int16(settings, iter.i16);
3764 if (!WINPR_JSON_AddNumberToObject(jint16, name, (double)val))
3765 goto fail;
3766 }
3767 break;
3768 case RDP_SETTINGS_TYPE_UINT32:
3769 {
3770 const uint32_t val = freerdp_settings_get_uint32(settings, iter.u32);
3771 if (!WINPR_JSON_AddNumberToObject(juint32, name, (double)val))
3772 goto fail;
3773 }
3774 break;
3775 case RDP_SETTINGS_TYPE_INT32:
3776 {
3777 const int32_t val = freerdp_settings_get_int32(settings, iter.i32);
3778 if (!WINPR_JSON_AddNumberToObject(jint32, name, (double)val))
3779 goto fail;
3780 }
3781 break;
3782 case RDP_SETTINGS_TYPE_UINT64:
3783 {
3784 const uint64_t val = freerdp_settings_get_uint64(settings, iter.u64);
3785 if (!WINPR_JSON_AddNumberToObject(juint64, name, (double)val))
3786 goto fail;
3787 }
3788 break;
3789 case RDP_SETTINGS_TYPE_INT64:
3790 {
3791 const int64_t val = freerdp_settings_get_int64(settings, iter.i64);
3792 if (!WINPR_JSON_AddNumberToObject(jint64, name, (double)val))
3793 goto fail;
3794 }
3795 break;
3796 case RDP_SETTINGS_TYPE_STRING:
3797 {
3798 const char* val = freerdp_settings_get_string(settings, iter.str);
3799 if (val)
3800 {
3801 if (!WINPR_JSON_AddStringToObject(jstring, name, val))
3802 goto fail;
3803 }
3804 else
3805 {
3806 (void)WINPR_JSON_AddNullToObject(jstring, name);
3807 }
3808 }
3809 break;
3810 case RDP_SETTINGS_TYPE_POINTER:
3811 if (!serialize_pointer(settings, jpointer, iter.ptr))
3812 goto fail;
3813 break;
3814 default:
3815 break;
3816 }
3817 }
3818
3819 if (pretty)
3820 str = WINPR_JSON_Print(json);
3821 else
3822 str = WINPR_JSON_PrintUnformatted(json);
3823
3824 if (!str)
3825 goto fail;
3826 if (plength)
3827 *plength = strlen(str);
3828
3829fail:
3830 WINPR_JSON_Delete(json);
3831 return str;
3832}
3833
3834static BOOL val_from_array(rdpSettings* settings, const WINPR_JSON* json,
3835 FreeRDP_Settings_Keys_Pointer key, size_t esize)
3836{
3837 if (WINPR_JSON_IsNull(json))
3838 return freerdp_settings_set_pointer(settings, key, NULL);
3839 if (!WINPR_JSON_IsArray(json))
3840 return FALSE;
3841
3842 size_t len = WINPR_JSON_GetArraySize(json);
3843 if (len == 0)
3844 return freerdp_settings_set_pointer(settings, key, NULL);
3845
3846 size_t count = len / esize;
3847 if (count * esize != len)
3848 return FALSE;
3849
3850 if (!freerdp_settings_set_pointer_len(settings, key, NULL, count))
3851 return FALSE;
3852
3853 BYTE* data = freerdp_settings_get_pointer_writable(settings, key);
3854 if (!data)
3855 return FALSE;
3856
3857 errno = 0;
3858 for (size_t x = 0; x < len; x++)
3859 {
3860 WINPR_JSON* val = WINPR_JSON_GetArrayItem(json, x);
3861 data[x] = (uint8_t)uint_from_json_item(val, UINT8_MAX);
3862 }
3863
3864 return errno == 0;
3865}
3866
3867static BOOL uintptr_from_array(rdpSettings* settings, const WINPR_JSON* json)
3868{
3869 FreeRDP_Settings_Keys_Pointer key = FreeRDP_instance;
3870 if (!json || !WINPR_JSON_IsArray(json))
3871 return FALSE;
3872
3873 size_t len = WINPR_JSON_GetArraySize(json);
3874 if (len > sizeof(void*))
3875 return FALSE;
3876
3877 if (len == 0)
3878 return freerdp_settings_set_pointer(settings, key, NULL);
3879
3880 union
3881 {
3882 void* v;
3883 uint8_t u[sizeof(void*)];
3884 } ptr;
3885
3886 errno = 0;
3887 for (size_t x = 0; x < len; x++)
3888 {
3889 WINPR_JSON* val = WINPR_JSON_GetArrayItem(json, x);
3890 ptr.u[x] = (uint8_t)uint_from_json_item(val, UINT8_MAX);
3891 }
3892 if (errno != 0)
3893 return FALSE;
3894 return freerdp_settings_set_pointer(settings, key, ptr.v);
3895}
3896
3897static BOOL val_from_uint32_array(rdpSettings* settings, const WINPR_JSON* json,
3898 FreeRDP_Settings_Keys_Pointer key,
3899 FreeRDP_Settings_Keys_UInt32 keyId)
3900{
3901 if (WINPR_JSON_IsNull(json))
3902 return freerdp_settings_set_pointer(settings, key, NULL);
3903 if (!WINPR_JSON_IsArray(json))
3904 return FALSE;
3905
3906 const size_t len = WINPR_JSON_GetArraySize(json);
3907 if ((FreeRDP_UINT32_UNUSED != keyId) && (freerdp_settings_get_uint32(settings, keyId) != len))
3908 {
3909 if (!freerdp_settings_set_pointer_len(settings, key, NULL, len))
3910 return FALSE;
3911 }
3912
3913 errno = 0;
3914 for (size_t x = 0; x < len; x++)
3915 {
3916 UINT32* data = freerdp_settings_get_pointer_array_writable(settings, key, x);
3917 if (!data)
3918 return FALSE;
3919
3920 WINPR_JSON* val = WINPR_JSON_GetArrayItem(json, x);
3921 data[0] = (uint32_t)uint_from_json_item(val, UINT32_MAX);
3922 }
3923 return errno == 0;
3924}
3925
3926static BOOL caps_data_entry_from_json(rdpSettings* settings, size_t offset, const WINPR_JSON* json)
3927{
3928 if (!json || !WINPR_JSON_IsArray(json))
3929 return FALSE;
3930
3931 const size_t size = WINPR_JSON_GetArraySize(json);
3932 if (size == 0)
3933 {
3934 return freerdp_settings_set_pointer_array(settings, FreeRDP_ReceivedCapabilityData, offset,
3935 NULL);
3936 }
3937
3938 uint8_t* data = calloc(size, sizeof(uint8_t));
3939 if (!data)
3940 return FALSE;
3941
3942 if (!freerdp_settings_set_pointer_array(settings, FreeRDP_ReceivedCapabilityData, offset, data))
3943 {
3944 free(data);
3945 return FALSE;
3946 }
3947
3948 errno = 0;
3949 for (size_t x = 0; x < size; x++)
3950 {
3951 WINPR_JSON* item = WINPR_JSON_GetArrayItem(json, x);
3952 data[x] = (uint8_t)uint_from_json_item(item, UINT8_MAX);
3953 }
3954
3955 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
3956 return errno == 0;
3957}
3958
3959static BOOL caps_data_array_from_json(rdpSettings* settings, const WINPR_JSON* json)
3960{
3961 if (!json || !WINPR_JSON_IsArray(json))
3962 return FALSE;
3963
3964 const size_t count = WINPR_JSON_GetArraySize(json);
3965 if (!freerdp_settings_set_pointer_len(settings, FreeRDP_ReceivedCapabilityData, NULL, count))
3966 return FALSE;
3967
3968 for (uint32_t x = 0; x < count; x++)
3969 {
3970 WINPR_JSON* array = WINPR_JSON_GetArrayItem(json, x);
3971 if (!caps_data_entry_from_json(settings, x, array))
3972 return FALSE;
3973 }
3974 return TRUE;
3975}
3976
3977static BOOL str_array_from_json(rdpSettings* settings, const WINPR_JSON* json,
3978 FreeRDP_Settings_Keys_Pointer key)
3979{
3980 if (WINPR_JSON_IsNull(json))
3981 return freerdp_settings_set_pointer_len(settings, key, NULL, 0);
3982 if (!WINPR_JSON_IsArray(json))
3983 return FALSE;
3984
3985 size_t len = WINPR_JSON_GetArraySize(json);
3986 if (!freerdp_settings_set_pointer_len(settings, key, NULL, len))
3987 return FALSE;
3988
3989 for (size_t x = 0; x < len; x++)
3990 {
3991 WINPR_JSON* cval = WINPR_JSON_GetArrayItem(json, x);
3992 if (!cval)
3993 return FALSE;
3994 if (!WINPR_JSON_IsString(cval))
3995 return FALSE;
3996
3997 const char* val = WINPR_JSON_GetStringValue(cval);
3998 if (!freerdp_settings_set_pointer_array(settings, key, x, val))
3999 return FALSE;
4000 }
4001 return TRUE;
4002}
4003
4004static BOOL addin_argv_from_json(rdpSettings* settings, const WINPR_JSON* json,
4005 FreeRDP_Settings_Keys_Pointer key)
4006{
4007 if (WINPR_JSON_IsNull(json))
4008 return freerdp_settings_set_pointer(settings, key, NULL);
4009
4010 if (!WINPR_JSON_IsArray(json))
4011 return FALSE;
4012
4013 size_t len = WINPR_JSON_GetArraySize(json);
4014 if (!freerdp_settings_set_pointer_len(settings, key, NULL, len))
4015 return FALSE;
4016
4017 for (size_t x = 0; x < len; x++)
4018 {
4019 WINPR_JSON* val = WINPR_JSON_GetArrayItem(json, x);
4020 if (val && WINPR_JSON_IsObject(val))
4021 {
4022 WINPR_JSON* jargc = WINPR_JSON_GetObjectItem(val, "argc");
4023 WINPR_JSON* array = WINPR_JSON_GetObjectItem(val, "argv");
4024 if (!jargc || !array)
4025 continue;
4026 if (!WINPR_JSON_IsNumber(jargc) || !WINPR_JSON_IsArray(array))
4027 continue;
4028
4029 const int argc = (int)int_from_json_item(jargc, INT32_MIN, INT32_MAX);
4030 if (errno != 0)
4031 return FALSE;
4032 const size_t jlen = WINPR_JSON_GetArraySize(array);
4033 if (jlen != (size_t)argc)
4034 return FALSE;
4035 if (jlen == 0)
4036 continue;
4037
4038 const char** argv = (const char**)calloc(jlen, sizeof(char*));
4039 if (!argv)
4040 return FALSE;
4041 for (size_t y = 0; y < jlen; y++)
4042 {
4043 WINPR_JSON* item = WINPR_JSON_GetArrayItem(array, y);
4044 if (!item || !WINPR_JSON_IsString(item))
4045 {
4046 free((void*)argv);
4047 return FALSE;
4048 }
4049 argv[y] = WINPR_JSON_GetStringValue(item);
4050 }
4051
4052 ADDIN_ARGV* cval = freerdp_addin_argv_new(jlen, argv);
4053 free((void*)argv);
4054 if (!cval)
4055 return FALSE;
4056 const BOOL rc = freerdp_settings_set_pointer_array(settings, key, x, cval);
4057 freerdp_addin_argv_free(cval);
4058 if (!rc)
4059 return FALSE;
4060 }
4061 }
4062 return TRUE;
4063}
4064
4065static char* get_string(const WINPR_JSON* json, const char* key)
4066{
4067 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, key);
4068 if (!item || !WINPR_JSON_IsString(item))
4069 return NULL;
4070 const char* str = WINPR_JSON_GetStringValue(item);
4071 return WINPR_CAST_CONST_PTR_AWAY(str, char*);
4072}
4073
4074static BOOL get_bool(const WINPR_JSON* json, const char* key)
4075{
4076 WINPR_JSON* item = WINPR_JSON_GetObjectItem(json, key);
4077 if (!item || !WINPR_JSON_IsBool(item))
4078 return FALSE;
4079 return WINPR_JSON_IsTrue(item);
4080}
4081
4082static BOOL device_from_json_item(rdpSettings* settings, FreeRDP_Settings_Keys_Pointer key,
4083 size_t offset, const WINPR_JSON* val)
4084{
4085 if (!val || !WINPR_JSON_IsObject(val))
4086 return FALSE;
4087
4088 union
4089 {
4090 RDPDR_DEVICE base;
4091 RDPDR_PARALLEL parallel;
4092 RDPDR_SERIAL serial;
4093 RDPDR_SMARTCARD smartcard;
4094 RDPDR_PRINTER printer;
4095 RDPDR_DRIVE drive;
4096 RDPDR_DEVICE device;
4097 } device;
4098
4099 memset(&device, 0, sizeof(device));
4100
4101 errno = 0;
4102 device.base.Id = (uint32_t)uint_from_json(val, "Id", UINT32_MAX);
4103 device.base.Type = (uint32_t)uint_from_json(val, "Type", UINT32_MAX);
4104 if (errno != 0)
4105 return FALSE;
4106 device.base.Name = get_string(val, "Name");
4107 if (!device.base.Name)
4108 return FALSE;
4109
4110 switch (device.base.Type)
4111 {
4112 case RDPDR_DTYP_SERIAL:
4113 device.serial.Path = get_string(val, "Path");
4114 device.serial.Driver = get_string(val, "Driver");
4115 device.serial.Permissive = get_string(val, "Permissive");
4116 break;
4117 case RDPDR_DTYP_PARALLEL:
4118 device.parallel.Path = get_string(val, "Path");
4119 break;
4120 case RDPDR_DTYP_PRINT:
4121 device.printer.DriverName = get_string(val, "DriverName");
4122 device.printer.IsDefault = get_bool(val, "IsDefault");
4123 break;
4124 case RDPDR_DTYP_FILESYSTEM:
4125 device.drive.Path = get_string(val, "Path");
4126 device.drive.automount = get_bool(val, "automount");
4127 break;
4128 case RDPDR_DTYP_SMARTCARD:
4129 default:
4130 break;
4131 }
4132 return freerdp_settings_set_pointer_array(settings, key, offset, &device);
4133}
4134
4135static BOOL device_array_from_json(rdpSettings* settings, const WINPR_JSON* json,
4136 FreeRDP_Settings_Keys_Pointer key)
4137{
4138 if (WINPR_JSON_IsNull(json))
4139 return freerdp_settings_set_pointer(settings, key, NULL);
4140
4141 if (!WINPR_JSON_IsArray(json))
4142 return FALSE;
4143
4144 size_t len = WINPR_JSON_GetArraySize(json);
4145 if (!freerdp_settings_set_pointer_len(settings, key, NULL, len))
4146 return FALSE;
4147
4148 for (size_t x = 0; x < len; x++)
4149 {
4150 WINPR_JSON* val = WINPR_JSON_GetArrayItem(json, x);
4151 if (!device_from_json_item(settings, key, x, val))
4152 return FALSE;
4153 }
4154 return TRUE;
4155}
4156
4157static const char* pem_from_json(const WINPR_JSON* jval, size_t* plen, BOOL* pvalid)
4158{
4159 WINPR_ASSERT(jval);
4160 WINPR_ASSERT(plen);
4161 WINPR_ASSERT(pvalid);
4162
4163 *pvalid = FALSE;
4164 *plen = 0;
4165
4166 if (WINPR_JSON_IsNull(jval))
4167 return NULL;
4168
4169 size_t len = WINPR_JSON_GetArraySize(jval);
4170 if (len == 0)
4171 {
4172 *pvalid = TRUE;
4173 return NULL;
4174 }
4175
4176 WINPR_JSON* item = WINPR_JSON_GetArrayItem(jval, 0);
4177 if (!item)
4178 return NULL;
4179 if (!WINPR_JSON_IsString(item))
4180 return NULL;
4181
4182 *plen = len;
4183 *pvalid = TRUE;
4184 return WINPR_JSON_GetStringValue(item);
4185}
4186
4187static BOOL deserialize_pointer(const WINPR_JSON* json, rdpSettings* settings,
4188 FreeRDP_Settings_Keys_Pointer id)
4189{
4190 const char* name = freerdp_settings_get_name_for_key(id);
4191 if (!name)
4192 return FALSE;
4193
4194 if (!WINPR_JSON_HasObjectItem(json, name))
4195 return FALSE;
4196
4197 WINPR_JSON* jval = WINPR_JSON_GetObjectItem(json, name);
4198 if (!WINPR_JSON_IsNull(jval) && !WINPR_JSON_IsArray(jval))
4199 return FALSE;
4200
4201 switch (id)
4202 {
4203 case FreeRDP_instance:
4204 return uintptr_from_array(settings, jval);
4205 case FreeRDP_ServerRandom:
4206 case FreeRDP_ServerCertificate:
4207 case FreeRDP_ClientRandom:
4208 case FreeRDP_RedirectionPassword:
4209 case FreeRDP_RedirectionGuid:
4210 case FreeRDP_LoadBalanceInfo:
4211 case FreeRDP_RedirectionTsvUrl:
4212 case FreeRDP_OrderSupport:
4213 case FreeRDP_Password51:
4214 return val_from_array(settings, jval, id, 1);
4215 case FreeRDP_ReceivedCapabilities:
4216 return val_from_array(settings, jval, id, 1);
4217 case FreeRDP_ClientTimeZone:
4218 return ts_info_array_from_json(settings, id, jval);
4219 case FreeRDP_GlyphCache:
4220 return glyph_cache_def_array_from_json(settings, id, jval);
4221 case FreeRDP_FragCache:
4222 return glyph_cache_def_array_from_json(settings, id, jval);
4223 case FreeRDP_BitmapCacheV2CellInfo:
4224 return bitmap_cache_v2_array_from_json(settings, id, jval);
4225 case FreeRDP_ClientAutoReconnectCookie:
4226 return client_cookie_array_from_json(settings, id, jval);
4227 case FreeRDP_ServerAutoReconnectCookie:
4228 return server_cookie_array_from_json(settings, id, jval);
4229 case FreeRDP_MonitorDefArray:
4230 return monitor_def_array_from_json(settings, id, jval);
4231 case FreeRDP_ChannelDefArray:
4232 return channel_def_array_from_json(settings, id, jval);
4233 case FreeRDP_MonitorIds:
4234 return val_from_uint32_array(settings, jval, id, FreeRDP_NumMonitorIds);
4235 case FreeRDP_TargetNetPorts:
4236 return val_from_uint32_array(settings, jval, id, FreeRDP_TargetNetAddressCount);
4237 case FreeRDP_ServerLicenseProductIssuers:
4238 case FreeRDP_TargetNetAddresses:
4239 return str_array_from_json(settings, jval, id);
4240 case FreeRDP_ReceivedCapabilityDataSizes:
4241 return val_from_uint32_array(settings, jval, id, FreeRDP_ReceivedCapabilitiesSize);
4242 case FreeRDP_ReceivedCapabilityData:
4243 return caps_data_array_from_json(settings, jval);
4244 case FreeRDP_RedirectionTargetCertificate:
4245 case FreeRDP_RdpServerCertificate:
4246 {
4247 size_t len = 0;
4248 BOOL valid = FALSE;
4249 const char* pem = pem_from_json(jval, &len, &valid);
4250 if (!valid)
4251 return FALSE;
4252 if (!freerdp_settings_set_pointer_len(settings, id, NULL, len))
4253 return FALSE;
4254
4255 rdpCertificate* cert = NULL;
4256 if (!pem)
4257 return TRUE;
4258
4259 if (strnlen(pem, 2) == 0)
4260 cert = freerdp_certificate_new();
4261 else
4262 cert = freerdp_certificate_new_from_pem(pem);
4263 if (!cert)
4264 return FALSE;
4265 return freerdp_settings_set_pointer_len(settings, id, cert, 1);
4266 }
4267 case FreeRDP_RdpServerRsaKey:
4268 {
4269 size_t len = 0;
4270 BOOL valid = FALSE;
4271 const char* pem = pem_from_json(jval, &len, &valid);
4272 if (!valid)
4273 return FALSE;
4274 if (!freerdp_settings_set_pointer_len(settings, id, NULL, len))
4275 return FALSE;
4276 if (!pem)
4277 return TRUE;
4278
4279 rdpPrivateKey* key = freerdp_key_new_from_pem_enc(pem, NULL);
4280 if (!key)
4281 return FALSE;
4282 return freerdp_settings_set_pointer_len(settings, id, key, 1);
4283 }
4284 case FreeRDP_DeviceArray:
4285 return device_array_from_json(settings, jval, id);
4286 case FreeRDP_StaticChannelArray:
4287 case FreeRDP_DynamicChannelArray:
4288 return addin_argv_from_json(settings, jval, id);
4289 case FreeRDP_POINTER_UNUSED:
4290 default:
4291 return TRUE;
4292 }
4293}
4294
4295rdpSettings* freerdp_settings_deserialize(const char* jstr, size_t length)
4296{
4297 WINPR_JSON* json = WINPR_JSON_ParseWithLength(jstr, length);
4298 if (!json)
4299 return NULL;
4300 rdpSettings* settings = freerdp_settings_new(0);
4301 if (!settings)
4302 goto fail;
4303
4304 WINPR_JSON* jbool = WINPR_JSON_GetObjectItem(
4305 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_BOOL));
4306 if (!jbool)
4307 goto fail;
4308 WINPR_JSON* juint16 = WINPR_JSON_GetObjectItem(
4309 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT16));
4310 if (!juint16)
4311 goto fail;
4312 WINPR_JSON* jint16 = WINPR_JSON_GetObjectItem(
4313 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT16));
4314 if (!jint16)
4315 goto fail;
4316 WINPR_JSON* juint32 = WINPR_JSON_GetObjectItem(
4317 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT32));
4318 if (!juint32)
4319 goto fail;
4320 WINPR_JSON* jint32 = WINPR_JSON_GetObjectItem(
4321 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT32));
4322 if (!jint32)
4323 goto fail;
4324 WINPR_JSON* juint64 = WINPR_JSON_GetObjectItem(
4325 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_UINT64));
4326 if (!juint64)
4327 goto fail;
4328 WINPR_JSON* jint64 = WINPR_JSON_GetObjectItem(
4329 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_INT64));
4330 if (!jint64)
4331 goto fail;
4332 WINPR_JSON* jstring = WINPR_JSON_GetObjectItem(
4333 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_STRING));
4334 if (!jstring)
4335 goto fail;
4336 WINPR_JSON* jpointer = WINPR_JSON_GetObjectItem(
4337 json, freerdp_settings_get_type_name_for_type(RDP_SETTINGS_TYPE_POINTER));
4338 if (!jpointer)
4339 goto fail;
4340
4341 for (int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
4342 {
4343 union
4344 {
4345
4346 int s;
4347 FreeRDP_Settings_Keys_Bool b;
4348 FreeRDP_Settings_Keys_Int16 i16;
4349 FreeRDP_Settings_Keys_UInt16 u16;
4350 FreeRDP_Settings_Keys_Int32 i32;
4351 FreeRDP_Settings_Keys_UInt32 u32;
4352 FreeRDP_Settings_Keys_Int64 i64;
4353 FreeRDP_Settings_Keys_UInt64 u64;
4354 FreeRDP_Settings_Keys_String str;
4355 FreeRDP_Settings_Keys_Pointer ptr;
4356 } iter;
4357 iter.s = x;
4358
4359 SSIZE_T type = freerdp_settings_get_type_for_key(iter.s);
4360 switch (type)
4361 {
4362 case RDP_SETTINGS_TYPE_POINTER:
4363 if (!deserialize_pointer(jpointer, settings, iter.ptr))
4364 goto fail;
4365 break;
4366 default:
4367 break;
4368 }
4369 }
4370
4371 for (int x = 0; x < FreeRDP_Settings_StableAPI_MAX; x++)
4372 {
4373 union
4374 {
4375
4376 int s;
4377 FreeRDP_Settings_Keys_Bool b;
4378 FreeRDP_Settings_Keys_Int16 i16;
4379 FreeRDP_Settings_Keys_UInt16 u16;
4380 FreeRDP_Settings_Keys_Int32 i32;
4381 FreeRDP_Settings_Keys_UInt32 u32;
4382 FreeRDP_Settings_Keys_Int64 i64;
4383 FreeRDP_Settings_Keys_UInt64 u64;
4384 FreeRDP_Settings_Keys_String str;
4385 FreeRDP_Settings_Keys_Pointer ptr;
4386 } iter;
4387 iter.s = x;
4388
4389 const char* name = freerdp_settings_get_name_for_key(iter.s);
4390 SSIZE_T type = freerdp_settings_get_type_for_key(iter.s);
4391 switch (type)
4392 {
4393 case RDP_SETTINGS_TYPE_BOOL:
4394 {
4395 WINPR_JSON* item = WINPR_JSON_GetObjectItem(jbool, name);
4396 if (!item)
4397 goto fail;
4398 if (!WINPR_JSON_IsBool(item))
4399 goto fail;
4400 const BOOL val = WINPR_JSON_IsTrue(item);
4401 if (!freerdp_settings_set_bool(settings, iter.b, val))
4402 goto fail;
4403 }
4404 break;
4405 case RDP_SETTINGS_TYPE_UINT16:
4406 {
4407 WINPR_JSON* item = WINPR_JSON_GetObjectItem(juint16, name);
4408 const uint16_t val = (uint16_t)uint_from_json_item(item, UINT16_MAX);
4409 if (errno != 0)
4410 goto fail;
4411 if (!freerdp_settings_set_uint16(settings, iter.u16, val))
4412 goto fail;
4413 }
4414 break;
4415 case RDP_SETTINGS_TYPE_INT16:
4416 {
4417 WINPR_JSON* item = WINPR_JSON_GetObjectItem(jint16, name);
4418 const int16_t val = (int16_t)int_from_json_item(item, INT16_MIN, INT16_MAX);
4419 if (errno != 0)
4420 goto fail;
4421 if (!freerdp_settings_set_int16(settings, iter.i16, val))
4422 goto fail;
4423 }
4424 break;
4425 case RDP_SETTINGS_TYPE_UINT32:
4426 {
4427 WINPR_JSON* item = WINPR_JSON_GetObjectItem(juint32, name);
4428 const uint32_t val = (uint32_t)uint_from_json_item(item, UINT32_MAX);
4429 if (errno != 0)
4430 goto fail;
4431 if (!freerdp_settings_set_uint32(settings, iter.u32, val))
4432 goto fail;
4433 }
4434 break;
4435 case RDP_SETTINGS_TYPE_INT32:
4436 {
4437 const int64_t val = int_from_json(jint32, name, INT32_MIN, INT32_MAX);
4438 if (errno != 0)
4439 goto fail;
4440 if (!freerdp_settings_set_int32(settings, iter.i32, (int32_t)val))
4441 goto fail;
4442 }
4443 break;
4444 case RDP_SETTINGS_TYPE_UINT64:
4445 {
4446 const uint64_t val = uint_from_json(juint64, name, UINT64_MAX);
4447 if (errno != 0)
4448 goto fail;
4449 if (!freerdp_settings_set_uint64(settings, iter.u64, val))
4450 goto fail;
4451 }
4452 break;
4453 case RDP_SETTINGS_TYPE_INT64:
4454 {
4455 WINPR_JSON* item = WINPR_JSON_GetObjectItem(jint64, name);
4456 const int64_t val = int_from_json_item(item, INT64_MIN, INT64_MAX);
4457 if (errno != 0)
4458 goto fail;
4459 if (!freerdp_settings_set_int64(settings, iter.i64, val))
4460 goto fail;
4461 }
4462 break;
4463 case RDP_SETTINGS_TYPE_STRING:
4464 {
4465 const char* val = NULL;
4466 WINPR_JSON* item = WINPR_JSON_GetObjectItem(jstring, name);
4467 if (item && !WINPR_JSON_IsNull(item))
4468 {
4469 if (!WINPR_JSON_IsString(item))
4470 goto fail;
4471 val = WINPR_JSON_GetStringValue(item);
4472 if (!val)
4473 goto fail;
4474 }
4475 if (!freerdp_settings_set_string(settings, iter.str, val))
4476 goto fail;
4477 }
4478 break;
4479 case RDP_SETTINGS_TYPE_POINTER:
4480 default:
4481 break;
4482 }
4483 }
4484
4485 WINPR_JSON_Delete(json);
4486 return settings;
4487
4488fail:
4489 freerdp_settings_free(settings);
4490 WINPR_JSON_Delete(json);
4491 return NULL;
4492}
WINPR_JSON_CreateString
WINPR_API WINPR_JSON * WINPR_JSON_CreateString(const char *string)
WINPR_JSON_CreateString.
Definition json.c:442
WINPR_JSON_HasObjectItem
WINPR_API BOOL WINPR_JSON_HasObjectItem(const WINPR_JSON *object, const char *string)
Check if JSON has an object matching the name.
Definition json.c:210
WINPR_JSON_AddNumberToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddNumberToObject(WINPR_JSON *object, const char *name, double number)
WINPR_JSON_AddNumberToObject.
Definition json.c:553
WINPR_JSON_IsNull
WINPR_API BOOL WINPR_JSON_IsNull(const WINPR_JSON *item)
Check if JSON item is Null.
Definition json.c:324
WINPR_JSON_GetObjectItem
WINPR_API WINPR_JSON * WINPR_JSON_GetObjectItem(const WINPR_JSON *object, const char *string)
Return a pointer to an JSON object item.
Definition json.c:184
WINPR_JSON_IsString
WINPR_API BOOL WINPR_JSON_IsString(const WINPR_JSON *item)
Check if JSON item is of type String.
Definition json.c:349
WINPR_JSON_AddItemToArray
WINPR_API BOOL WINPR_JSON_AddItemToArray(WINPR_JSON *array, WINPR_JSON *item)
Add an item to an existing array.
Definition json.c:612
WINPR_JSON_AddArrayToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddArrayToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddArrayToObject.
Definition json.c:635
WINPR_JSON_IsBool
WINPR_API BOOL WINPR_JSON_IsBool(const WINPR_JSON *item)
Check if JSON item is of type BOOL.
Definition json.c:312
WINPR_JSON_GetNumberValue
WINPR_API double WINPR_JSON_GetNumberValue(const WINPR_JSON *item)
Return the Number value of a JSON item.
Definition json.c:246
WINPR_JSON_CreateObject
WINPR_API WINPR_JSON * WINPR_JSON_CreateObject(void)
WINPR_JSON_CreateObject.
Definition json.c:465
WINPR_JSON_CreateArray
WINPR_API WINPR_JSON * WINPR_JSON_CreateArray(void)
WINPR_JSON_CreateArray.
Definition json.c:454
WINPR_JSON_Print
WINPR_API char * WINPR_JSON_Print(WINPR_JSON *item)
Serialize a JSON instance to string for minimal size without formatting see WINPR_JSON_PrintUnformatt...
Definition json.c:654
WINPR_JSON_IsNumber
WINPR_API BOOL WINPR_JSON_IsNumber(const WINPR_JSON *item)
Check if JSON item is of type Number.
Definition json.c:336
WINPR_JSON_GetArrayItem
WINPR_API WINPR_JSON * WINPR_JSON_GetArrayItem(const WINPR_JSON *array, size_t index)
Return a pointer to an item in the array.
Definition json.c:155
WINPR_JSON_AddStringToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddStringToObject(WINPR_JSON *object, const char *name, const char *string)
WINPR_JSON_AddStringToObject.
Definition json.c:573
WINPR_JSON_ParseWithLength
WINPR_API WINPR_JSON * WINPR_JSON_ParseWithLength(const char *value, size_t buffer_length)
Parse a JSON string.
Definition json.c:125
WINPR_JSON_CreateNumber
WINPR_API WINPR_JSON * WINPR_JSON_CreateNumber(double num)
WINPR_JSON_CreateNumber.
Definition json.c:430
WINPR_JSON_IsObject
WINPR_API BOOL WINPR_JSON_IsObject(const WINPR_JSON *item)
Check if JSON item is of type Object.
Definition json.c:373
WINPR_JSON_AddBoolToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddBoolToObject(WINPR_JSON *object, const char *name, BOOL boolean)
WINPR_JSON_AddBoolToObject.
Definition json.c:533
WINPR_JSON_PrintUnformatted
WINPR_API char * WINPR_JSON_PrintUnformatted(WINPR_JSON *item)
Serialize a JSON instance to string without formatting for human readable formatted output see WINPR_...
Definition json.c:669
WINPR_JSON_CreateNull
WINPR_API WINPR_JSON * WINPR_JSON_CreateNull(void)
WINPR_JSON_CreateNull.
Definition json.c:385
WINPR_JSON_GetStringValue
WINPR_API const char * WINPR_JSON_GetStringValue(WINPR_JSON *item)
Return the String value of a JSON item.
Definition json.c:234
WINPR_JSON_AddNullToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddNullToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddNullToObject.
Definition json.c:476
WINPR_JSON_Delete
WINPR_API void WINPR_JSON_Delete(WINPR_JSON *item)
Delete a WinPR JSON wrapper object.
Definition json.c:144
WINPR_JSON_GetArraySize
WINPR_API size_t WINPR_JSON_GetArraySize(const WINPR_JSON *array)
Get the number of arrayitems from an array.
Definition json.c:169
WINPR_JSON_IsArray
WINPR_API BOOL WINPR_JSON_IsArray(const WINPR_JSON *item)
Check if JSON item is of type Array.
Definition json.c:361
WINPR_JSON_AddObjectToObject
WINPR_API WINPR_JSON * WINPR_JSON_AddObjectToObject(WINPR_JSON *object, const char *name)
WINPR_JSON_AddObjectToObject.
Definition json.c:593
WINPR_JSON_IsTrue
WINPR_API BOOL WINPR_JSON_IsTrue(const WINPR_JSON *item)
Check if JSON item is BOOL value True.
Definition json.c:297
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_rail_support_flags_to_string
const char * freerdp_rail_support_flags_to_string(UINT32 flags, char *buffer, size_t length)
Returns a stringified representation of RAIL support flags.
Definition common/settings.c:2130
freerdp_settings_update_from_caps
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.
Definition common/settings.c:2165
freerdp_settings_set_string
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.
Definition settings_getters.c:3717
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_supported_color_depths_string
const char * freerdp_supported_color_depths_string(UINT16 mask, char *buffer, size_t size)
returns a string representation of RNS_UD_XXBPP_SUPPORT values
Definition common/settings.c:2348
freerdp_settings_new
FREERDP_API rdpSettings * freerdp_settings_new(DWORD flags)
creates a new setting struct
Definition core/settings.c:786
freerdp_settings_get_int64
FREERDP_API INT64 freerdp_settings_get_int64(const rdpSettings *settings, FreeRDP_Settings_Keys_Int64 id)
Returns a INT64 settings value.
freerdp_settings_set_string_from_utf16N
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.
Definition common/settings.c:2248
freerdp_rdp_version_string
const char * freerdp_rdp_version_string(UINT32 version)
Returns a stringified representation of the RDP protocol version.
Definition common/settings.c:2192
freerdp_settings_get_type_for_key
FREERDP_API SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key)
Get a key type for the key index.
Definition settings_str.c:410
freerdp_settings_are_valid
BOOL freerdp_settings_are_valid(const rdpSettings *settings)
Returns TRUE if settings are in a valid state, FALSE otherwise.
Definition common/settings.c:2393
freerdp_settings_get_uint64
FREERDP_API UINT64 freerdp_settings_get_uint64(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt64 id)
Returns a UINT64 settings value.
freerdp_settings_get_key_for_name
FREERDP_API SSIZE_T freerdp_settings_get_key_for_name(const char *value)
Get a key index for the name string of that key.
Definition settings_str.c:351
freerdp_settings_set_pointer_len
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.
Definition common/settings.c:1415
freerdp_settings_serialize
char * freerdp_settings_serialize(const rdpSettings *settings, BOOL pretty, size_t *plength)
A function that converts a rdpSettings struct to a JSON serialized string.
Definition common/settings.c:3674
freerdp_settings_set_int32
FREERDP_API BOOL freerdp_settings_set_int32(rdpSettings *settings, FreeRDP_Settings_Keys_Int32 id, INT32 param)
Sets a INT32 settings value.
freerdp_rdpdr_dtyp_string
const char * freerdp_rdpdr_dtyp_string(UINT32 type)
Returns a string representation of RDPDR_DTYP_*.
Definition common/settings.c:2282
freerdp_settings_free
FREERDP_API void freerdp_settings_free(rdpSettings *settings)
Free a settings struct with all data in it.
Definition core/settings.c:1292
freerdp_settings_set_monitor_def_array_sorted
BOOL freerdp_settings_set_monitor_def_array_sorted(rdpSettings *settings, const rdpMonitor *monitors, size_t count)
Sort monitor array according to:
Definition common/settings.c:2422
freerdp_settings_get_uint16
FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id)
Returns a UINT16 settings value.
freerdp_settings_get_pointer_writable
FREERDP_API void * freerdp_settings_get_pointer_writable(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a mutable pointer settings value.
Definition settings_getters.c:4068
freerdp_settings_get_string_as_utf16
WCHAR * freerdp_settings_get_string_as_utf16(const rdpSettings *settings, FreeRDP_Settings_Keys_String id, size_t *pCharLen)
Return an allocated UTF16 string.
Definition common/settings.c:2271
freerdp_device_collection_del
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.
Definition common/settings.c:240
freerdp_set_gateway_usage_method
BOOL freerdp_set_gateway_usage_method(rdpSettings *settings, UINT32 GatewayUsageMethod)
Definition common/settings.c:1099
freerdp_settings_set_uint64
FREERDP_API BOOL freerdp_settings_set_uint64(rdpSettings *settings, FreeRDP_Settings_Keys_UInt64 id, UINT64 param)
Sets a UINT64 settings value.
freerdp_settings_set_int16
FREERDP_API BOOL freerdp_settings_set_int16(rdpSettings *settings, FreeRDP_Settings_Keys_Int16 id, INT16 param)
Sets a INT16 settings value.
freerdp_settings_set_int64
FREERDP_API BOOL freerdp_settings_set_int64(rdpSettings *settings, FreeRDP_Settings_Keys_Int64 id, INT64 param)
Sets a INT64 settings value.
freerdp_settings_set_string_from_utf16
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.
Definition common/settings.c:2231
freerdp_settings_set_pointer
FREERDP_API BOOL freerdp_settings_set_pointer(rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id, const void *data)
Set a pointer to value data.
freerdp_settings_get_int32
FREERDP_API INT32 freerdp_settings_get_int32(const rdpSettings *settings, FreeRDP_Settings_Keys_Int32 id)
Returns a INT32 settings value.
freerdp_settings_get_server_name
const char * freerdp_settings_get_server_name(const rdpSettings *settings)
A helper function to return the correct server name.
Definition common/settings.c:1999
freerdp_settings_get_pointer
const void * freerdp_settings_get_pointer(const rdpSettings *settings, FreeRDP_Settings_Keys_Pointer id)
Returns a immutable pointer settings value.
Definition common/settings.c:1403
freerdp_settings_get_codecs_flags
UINT32 freerdp_settings_get_codecs_flags(const rdpSettings *settings)
helper function to get a mask of supported codec flags.
Definition common/settings.c:1984
freerdp_settings_set_string_len
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.
Definition settings_getters.c:3711
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
freerdp_settings_append_string
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...
Definition common/settings.c:2373
freerdp_settings_get_name_for_key
FREERDP_API const char * freerdp_settings_get_name_for_key(SSIZE_T key)
Returns the type name for a key.
Definition settings_str.c:421
freerdp_settings_get_string
FREERDP_API const char * freerdp_settings_get_string(const rdpSettings *settings, FreeRDP_Settings_Keys_String id)
Returns a immutable string settings value.
freerdp_settings_set_uint16
FREERDP_API BOOL freerdp_settings_set_uint16(rdpSettings *settings, FreeRDP_Settings_Keys_UInt16 id, UINT16 param)
Sets a UINT16 settings value.
freerdp_settings_get_type_name_for_type
FREERDP_API const char * freerdp_settings_get_type_name_for_type(SSIZE_T type)
Returns the type name for a type.
Definition settings_str.c:383
freerdp_settings_get_int16
FREERDP_API INT16 freerdp_settings_get_int16(const rdpSettings *settings, FreeRDP_Settings_Keys_Int16 id)
Returns a INT16 settings value.
freerdp_settings_set_bool
FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL param)
Sets a BOOL settings value.
freerdp_settings_deserialize
rdpSettings * freerdp_settings_deserialize(const char *jstr, size_t length)
A function that converts a JSON string to a rdpSettings struct.
Definition common/settings.c:4295
ADDIN_ARGV
Definition settings_types.h:367
ARC_CS_PRIVATE_PACKET
Definition settings_types.h:348
ARC_SC_PRIVATE_PACKET
Definition settings_types.h:357
BITMAP_CACHE_V2_CELL_INFO
Definition settings_types.h:389
GLYPH_CACHE_DEFINITION
Definition settings_types.h:397
MONITOR_ATTRIBUTES
Definition settings_types.h:414
RDPDR_DEVICE
Definition settings_types.h:441
RDPDR_DRIVE
Definition settings_types.h:448
RDPDR_PARALLEL
Definition settings_types.h:475
RDPDR_PRINTER
Definition settings_types.h:455
RDPDR_SERIAL
Definition settings_types.h:467
RDPDR_SMARTCARD
Definition settings_types.h:462
rdpMonitor
Definition settings_types.h:423
CHANNEL_DEF
Definition wtsapi.h:78
TIME_ZONE_INFORMATION
Definition winpr/include/winpr/timezone.h:36