FreeRDP
Loading...
Searching...
No Matches
pf_config.c
1
23#include <stdio.h>
24#include <string.h>
25#include <winpr/crt.h>
26#include <winpr/path.h>
27#include <winpr/collections.h>
28#include <winpr/cmdline.h>
29
30#include "pf_server.h"
31#include <freerdp/server/proxy/proxy_config.h>
32
33#include <freerdp/server/proxy/proxy_log.h>
34
35#include <freerdp/crypto/crypto.h>
36#include <freerdp/channels/cliprdr.h>
37#include <freerdp/channels/rdpsnd.h>
38#include <freerdp/channels/audin.h>
39#include <freerdp/channels/rdpdr.h>
40#include <freerdp/channels/disp.h>
41#include <freerdp/channels/rail.h>
42#include <freerdp/channels/rdpei.h>
43#include <freerdp/channels/tsmf.h>
44#include <freerdp/channels/video.h>
45#include <freerdp/channels/rdpecam.h>
46
47#include "pf_utils.h"
48
49#define TAG PROXY_TAG("config")
50
51#define CONFIG_PRINT_SECTION(section) WLog_INFO(TAG, "\t%s:", section)
52#define CONFIG_PRINT_SECTION_KEY(section, key) WLog_INFO(TAG, "\t%s/%s:", section, key)
53#define CONFIG_PRINT_STR(config, key) WLog_INFO(TAG, "\t\t%s: %s", #key, (config)->key)
54#define CONFIG_PRINT_SECRET_STR(config, key) \
55 WLog_INFO(TAG, "\t\t%s: %s", #key, (config)->key ? "********" : nullptr)
56#define CONFIG_PRINT_BOOL(config, key) WLog_INFO(TAG, "\t\t%s: %s", #key, boolstr((config)->key))
57#define CONFIG_PRINT_UINT16(config, key) WLog_INFO(TAG, "\t\t%s: %" PRIu16 "", #key, (config)->key)
58#define CONFIG_PRINT_UINT32(config, key) WLog_INFO(TAG, "\t\t%s: %" PRIu32 "", #key, (config)->key)
59
60static const char* bool_str_true = "true";
61static const char* bool_str_false = "false";
62
63WINPR_ATTR_NODISCARD
64static const char* boolstr(BOOL rc)
65{
66 return rc ? bool_str_true : bool_str_false;
67}
68
69static const char* section_server = "Server";
70static const char* key_host = "Host";
71static const char* key_port = "Port";
72static const char* key_sam_file = "SamFile";
73
74static const char* section_target = "Target";
75static const char* key_target_fixed = "FixedTarget";
76static const char* key_target_user = "User";
77static const char* key_target_pwd = "Password";
78static const char* key_target_domain = "Domain";
79static const char* key_target_tls_seclevel = "TlsSecLevel";
80static const char* key_target_scard_auth = "SmartcardAuth";
81static const char* key_target_scard_cert = "SmartcardCert";
82static const char* key_target_scard_key = "SmartcardKey";
83static const char* key_target_scard_pem_cert = "SmartcardCertPEMContent";
84static const char* key_target_scard_pem_key = "SmartcardKeyPEMContent";
85
86static const char* section_plugins = "Plugins";
87static const char* key_plugins_modules = "Modules";
88static const char* key_plugins_required = "Required";
89
90static const char* section_codecs = "Codecs";
91static const char* key_codecs_rfx = "RFX";
92static const char* key_codecs_nsc = "NSC";
93
94static const char* section_channels = "Channels";
95static const char* key_channels_gfx = "GFX";
96static const char* key_channels_disp = "DisplayControl";
97static const char* key_channels_clip = "Clipboard";
98static const char* key_channels_mic = "AudioInput";
99static const char* key_channels_sound = "AudioOutput";
100static const char* key_channels_rdpdr = "DeviceRedirection";
101static const char* key_channels_video = "VideoRedirection";
102static const char* key_channels_camera = "CameraRedirection";
103static const char* key_channels_rails = "RemoteApp";
104static const char* key_channels_blacklist = "PassthroughIsBlacklist";
105static const char* key_channels_pass = "Passthrough";
106static const char* key_channels_intercept = "Intercept";
107
108static const char* section_input = "Input";
109static const char* key_input_kbd = "Keyboard";
110static const char* key_input_mouse = "Mouse";
111static const char* key_input_multitouch = "Multitouch";
112
113static const char* section_security = "Security";
114static const char* key_security_server_nla = "ServerNlaSecurity";
115static const char* key_security_server_tls = "ServerTlsSecurity";
116static const char* key_security_server_rdp = "ServerRdpSecurity";
117static const char* key_security_client_nla = "ClientNlaSecurity";
118static const char* key_security_client_tls = "ClientTlsSecurity";
119static const char* key_security_client_rdp = "ClientRdpSecurity";
120static const char* key_security_client_fallback = "ClientAllowFallbackToTls";
121
122static const char* section_certificates = "Certificates";
123static const char* key_private_key_file = "PrivateKeyFile";
124static const char* key_private_key_content = "PrivateKeyContent";
125static const char* key_cert_file = "CertificateFile";
126static const char* key_cert_content = "CertificateContent";
127
128WINPR_ATTR_MALLOC(free, 1)
129static char* pf_config_decode_base64(const char* data, const char* name, size_t* pLength);
130
131WINPR_ATTR_MALLOC(CommandLineParserFree, 1)
132WINPR_ATTR_NODISCARD
133static char** pf_config_parse_comma_separated_list(const char* list, size_t* count)
134{
135 if (!list || !count)
136 return nullptr;
137
138 if (strlen(list) == 0)
139 {
140 *count = 0;
141 return nullptr;
142 }
143
144 return CommandLineParseCommaSeparatedValues(list, count);
145}
146
147WINPR_ATTR_NODISCARD
148static BOOL pf_config_get_uint16(wIniFile* ini, const char* section, const char* key,
149 UINT16* result, BOOL required)
150{
151 int val = 0;
152 const char* strval = nullptr;
153
154 WINPR_ASSERT(result);
155
156 strval = IniFile_GetKeyValueString(ini, section, key);
157 if (!strval && required)
158 {
159 WLog_ERR(TAG, "key '%s.%s' does not exist.", section, key);
160 return FALSE;
161 }
162 else if (!strval)
163 goto out;
164
165 val = IniFile_GetKeyValueInt(ini, section, key);
166 if ((val <= 0) || (val > UINT16_MAX))
167 {
168 WLog_ERR(TAG, "invalid value %d for key '%s.%s'.", val, section, key);
169 return FALSE;
170 }
171
172out:
173 *result = (UINT16)val;
174 return TRUE;
175}
176
177WINPR_ATTR_NODISCARD
178static BOOL pf_config_get_uint32(wIniFile* ini, const char* section, const char* key,
179 UINT32* result, BOOL required)
180{
181 WINPR_ASSERT(result);
182
183 const char* strval = IniFile_GetKeyValueString(ini, section, key);
184 if (!strval)
185 {
186 if (required)
187 WLog_ERR(TAG, "key '%s.%s' does not exist.", section, key);
188 return !required;
189 }
190
191 const int val = IniFile_GetKeyValueInt(ini, section, key);
192 if (val < 0)
193 {
194 WLog_ERR(TAG, "invalid value %d for key '%s.%s'.", val, section, key);
195 return FALSE;
196 }
197
198 *result = (UINT32)val;
199 return TRUE;
200}
201
202WINPR_ATTR_NODISCARD
203static BOOL pf_config_get_bool(wIniFile* ini, const char* section, const char* key, BOOL fallback)
204{
205 int num_value = 0;
206 const char* str_value = nullptr;
207
208 str_value = IniFile_GetKeyValueString(ini, section, key);
209 if (!str_value)
210 {
211 WLog_WARN(TAG, "key '%s.%s' not found, value defaults to %s.", section, key,
212 fallback ? bool_str_true : bool_str_false);
213 return fallback;
214 }
215
216 if (_stricmp(str_value, bool_str_true) == 0)
217 return TRUE;
218 if (_stricmp(str_value, bool_str_false) == 0)
219 return FALSE;
220
221 num_value = IniFile_GetKeyValueInt(ini, section, key);
222
223 return (num_value != 0);
224}
225
226WINPR_ATTR_NODISCARD
227static const char* pf_config_get_str(wIniFile* ini, const char* section, const char* key,
228 BOOL required)
229{
230 const char* value = IniFile_GetKeyValueString(ini, section, key);
231
232 if (!value)
233 {
234 if (required)
235 WLog_ERR(TAG, "key '%s.%s' not found.", section, key);
236 return nullptr;
237 }
238
239 return value;
240}
241
242static void zfree(char* str)
243{
244 if (!str)
245 return;
246 const size_t len = strlen(str);
247 memset(str, 0, len);
248 free(str);
249}
250
251static void znfree(char* str, size_t len)
252{
253 if (!str)
254 return;
255 memset(str, 0, len);
256 free(str);
257}
258
259WINPR_ATTR_NODISCARD
260static BOOL pf_config_copy_string(char** dst, const char* src)
261{
262 WINPR_ASSERT(dst);
263 *dst = nullptr;
264 if (src)
265 *dst = _strdup(src);
266 return TRUE;
267}
268
269WINPR_ATTR_NODISCARD
270static BOOL pf_config_free_and_copy_string(char** dst, const char* src)
271{
272 WINPR_ASSERT(dst);
273 zfree(*dst);
274 return pf_config_copy_string(dst, src);
275}
276
277WINPR_ATTR_NODISCARD
278static BOOL pf_config_load_server(wIniFile* ini, proxyConfig* config)
279{
280 WINPR_ASSERT(config);
281 const char* host = pf_config_get_str(ini, section_server, key_host, FALSE);
282
283 if (host)
284 {
285 if (!pf_config_free_and_copy_string(&config->Host, host))
286 return FALSE;
287 }
288
289 if (!pf_config_get_uint16(ini, section_server, key_port, &config->Port, FALSE))
290 return FALSE;
291
292 const char* sam = pf_config_get_str(ini, section_server, key_sam_file, FALSE);
293 if (sam)
294 {
295 if (!pf_config_free_and_copy_string(&config->SamFile, sam))
296 return FALSE;
297 }
298
299 return TRUE;
300}
301
302WINPR_ATTR_NODISCARD
303static BOOL pf_config_load_target(wIniFile* ini, proxyConfig* config)
304{
305 const char* target_value = nullptr;
306
307 WINPR_ASSERT(config);
308 config->FixedTarget = pf_config_get_bool(ini, section_target, key_target_fixed, FALSE);
309
310 if (!pf_config_get_uint32(ini, section_target, key_target_tls_seclevel,
311 &config->TargetTlsSecLevel, FALSE))
312 return FALSE;
313
314 if (config->FixedTarget)
315 {
316 if (!pf_config_get_uint16(ini, section_target, key_port, &config->TargetPort, FALSE))
317 return FALSE;
318
319 target_value = pf_config_get_str(ini, section_target, key_host, FALSE);
320 if (target_value)
321 {
322 if (!pf_config_free_and_copy_string(&config->TargetHost, target_value))
323 return FALSE;
324 }
325 }
326
327 target_value = pf_config_get_str(ini, section_target, key_target_user, FALSE);
328 if (target_value)
329 {
330 if (!pf_config_free_and_copy_string(&config->TargetUser, target_value))
331 return FALSE;
332 }
333
334 target_value = pf_config_get_str(ini, section_target, key_target_pwd, FALSE);
335 if (target_value)
336 {
337 if (!pf_config_free_and_copy_string(&config->TargetPassword, target_value))
338 return FALSE;
339 }
340
341 target_value = pf_config_get_str(ini, section_target, key_target_domain, FALSE);
342 if (target_value)
343 {
344 if (!pf_config_free_and_copy_string(&config->TargetDomain, target_value))
345 return FALSE;
346 }
347
348 config->TargetSmartcardAuth =
349 pf_config_get_bool(ini, section_target, key_target_scard_auth, FALSE);
350
351 target_value = pf_config_get_str(ini, section_target, key_target_scard_cert, FALSE);
352 if (target_value)
353 {
354 size_t len = 0;
355 char* pem = crypto_read_pem(target_value, &len);
356 if (!pem)
357 return FALSE;
358 znfree(config->TargetSmartcardCert, config->TargetSmartcardCertLength);
359 config->TargetSmartcardCert = pem;
360 config->TargetSmartcardCertLength = len;
361 }
362
363 {
364 const char* pem_value =
365 pf_config_get_str(ini, section_target, key_target_scard_pem_cert, FALSE);
366 if (pem_value)
367 {
368 if (target_value)
369 WLog_WARN(TAG, "In section [%s] both, '%s' and '%s' are provided. Ignoring %s",
370 section_target, key_target_scard_cert, key_target_scard_pem_cert,
371 key_target_scard_cert);
372 znfree(config->TargetSmartcardCert, config->TargetSmartcardCertLength);
373 size_t len = 0;
374 config->TargetSmartcardCert =
375 pf_config_decode_base64(pem_value, key_target_scard_pem_cert, &len);
376 if (!config->TargetSmartcardCert)
377 return FALSE;
378 config->TargetSmartcardCertLength = len;
379 }
380 }
381
382 target_value = pf_config_get_str(ini, section_target, key_target_scard_key, FALSE);
383 if (target_value)
384 {
385 size_t len = 0;
386 char* pem = crypto_read_pem(target_value, &len);
387 znfree(config->TargetSmartcardKey, config->TargetSmartcardKeyLength);
388 config->TargetSmartcardKey = pem;
389 config->TargetSmartcardKeyLength = len;
390 }
391
392 {
393 const char* pem_value =
394 pf_config_get_str(ini, section_target, key_target_scard_pem_key, FALSE);
395 if (pem_value)
396 {
397 if (target_value)
398 WLog_WARN(TAG, "In section [%s] both, '%s' and '%s' are provided. Ignoring %s",
399 section_target, key_target_scard_key, key_target_scard_pem_key,
400 key_target_scard_key);
401 znfree(config->TargetSmartcardKey, config->TargetSmartcardKeyLength);
402
403 size_t len = 0;
404 config->TargetSmartcardKey =
405 pf_config_decode_base64(pem_value, key_target_scard_pem_key, &len);
406 if (!config->TargetSmartcardKey)
407 return FALSE;
408 config->TargetSmartcardKeyLength = len;
409 }
410 }
411
412 return TRUE;
413}
414
415WINPR_ATTR_NODISCARD
416static BOOL pf_config_load_codecs(wIniFile* ini, proxyConfig* config)
417{
418 WINPR_ASSERT(config);
419 config->RFX = pf_config_get_bool(ini, section_codecs, key_codecs_rfx, TRUE);
420 config->NSC = pf_config_get_bool(ini, section_codecs, key_codecs_nsc, TRUE);
421 return TRUE;
422}
423
424WINPR_ATTR_NODISCARD
425static BOOL pf_config_load_channels(wIniFile* ini, proxyConfig* config)
426{
427 WINPR_ASSERT(config);
428 config->GFX = pf_config_get_bool(ini, section_channels, key_channels_gfx, TRUE);
429 config->DisplayControl = pf_config_get_bool(ini, section_channels, key_channels_disp, TRUE);
430 config->Clipboard = pf_config_get_bool(ini, section_channels, key_channels_clip, FALSE);
431 config->AudioOutput = pf_config_get_bool(ini, section_channels, key_channels_mic, TRUE);
432 config->AudioInput = pf_config_get_bool(ini, section_channels, key_channels_sound, TRUE);
433 config->DeviceRedirection = pf_config_get_bool(ini, section_channels, key_channels_rdpdr, TRUE);
434 config->VideoRedirection = pf_config_get_bool(ini, section_channels, key_channels_video, TRUE);
435 config->CameraRedirection =
436 pf_config_get_bool(ini, section_channels, key_channels_camera, TRUE);
437 config->RemoteApp = pf_config_get_bool(ini, section_channels, key_channels_rails, FALSE);
438 config->PassthroughIsBlacklist =
439 pf_config_get_bool(ini, section_channels, key_channels_blacklist, FALSE);
440 config->Passthrough = pf_config_parse_comma_separated_list(
441 pf_config_get_str(ini, section_channels, key_channels_pass, FALSE),
442 &config->PassthroughCount);
443 config->Intercept = pf_config_parse_comma_separated_list(
444 pf_config_get_str(ini, section_channels, key_channels_intercept, FALSE),
445 &config->InterceptCount);
446
447 return TRUE;
448}
449
450WINPR_ATTR_NODISCARD
451static BOOL pf_config_load_input(wIniFile* ini, proxyConfig* config)
452{
453 WINPR_ASSERT(config);
454 config->Keyboard = pf_config_get_bool(ini, section_input, key_input_kbd, TRUE);
455 config->Mouse = pf_config_get_bool(ini, section_input, key_input_mouse, TRUE);
456 config->Multitouch = pf_config_get_bool(ini, section_input, key_input_multitouch, TRUE);
457 return TRUE;
458}
459
460WINPR_ATTR_NODISCARD
461static BOOL pf_config_load_security(wIniFile* ini, proxyConfig* config)
462{
463 WINPR_ASSERT(config);
464 config->ServerTlsSecurity =
465 pf_config_get_bool(ini, section_security, key_security_server_tls, TRUE);
466 config->ServerNlaSecurity =
467 pf_config_get_bool(ini, section_security, key_security_server_nla, FALSE);
468 config->ServerRdpSecurity =
469 pf_config_get_bool(ini, section_security, key_security_server_rdp, TRUE);
470
471 config->ClientTlsSecurity =
472 pf_config_get_bool(ini, section_security, key_security_client_tls, TRUE);
473 config->ClientNlaSecurity =
474 pf_config_get_bool(ini, section_security, key_security_client_nla, TRUE);
475 config->ClientRdpSecurity =
476 pf_config_get_bool(ini, section_security, key_security_client_rdp, TRUE);
477 config->ClientAllowFallbackToTls =
478 pf_config_get_bool(ini, section_security, key_security_client_fallback, TRUE);
479 return TRUE;
480}
481
482WINPR_ATTR_NODISCARD
483static BOOL pf_config_load_modules(wIniFile* ini, proxyConfig* config)
484{
485 const char* modules_to_load = nullptr;
486 const char* required_modules = nullptr;
487
488 modules_to_load = pf_config_get_str(ini, section_plugins, key_plugins_modules, FALSE);
489 required_modules = pf_config_get_str(ini, section_plugins, key_plugins_required, FALSE);
490
491 WINPR_ASSERT(config);
492 config->Modules = pf_config_parse_comma_separated_list(modules_to_load, &config->ModulesCount);
493
494 config->RequiredPlugins =
495 pf_config_parse_comma_separated_list(required_modules, &config->RequiredPluginsCount);
496 return TRUE;
497}
498
499char* pf_config_decode_base64(const char* data, const char* name, size_t* pLength)
500{
501 const char* headers[] = { "-----BEGIN PUBLIC KEY-----", "-----BEGIN RSA PUBLIC KEY-----",
502 "-----BEGIN CERTIFICATE-----", "-----BEGIN PRIVATE KEY-----",
503 "-----BEGIN RSA PRIVATE KEY-----" };
504
505 size_t decoded_length = 0;
506 char* decoded = nullptr;
507 if (!data)
508 {
509 WLog_ERR(TAG, "Invalid base64 data [nullptr] for %s", name);
510 return nullptr;
511 }
512
513 WINPR_ASSERT(name);
514 WINPR_ASSERT(pLength);
515
516 const size_t length = strlen(data);
517
518 if (strncmp(data, "-----", 5) == 0)
519 {
520 BOOL expected = FALSE;
521 for (size_t x = 0; x < ARRAYSIZE(headers); x++)
522 {
523 const char* header = headers[x];
524
525 if (strncmp(data, header, strlen(header)) == 0)
526 expected = TRUE;
527 }
528
529 if (!expected)
530 {
531 /* Extract header for log message
532 * expected format is '----- SOMETEXT -----'
533 */
534 char hdr[128] = WINPR_C_ARRAY_INIT;
535 const char* end = strchr(&data[5], '-');
536 if (end)
537 {
538 while (*end == '-')
539 end++;
540
541 const size_t s = MIN(ARRAYSIZE(hdr) - 1ULL, (size_t)(end - data));
542 memcpy(hdr, data, s);
543 }
544
545 WLog_WARN(TAG, "PEM has unexpected header '%s'. Known supported headers are:", hdr);
546 for (size_t x = 0; x < ARRAYSIZE(headers); x++)
547 {
548 const char* header = headers[x];
549 WLog_WARN(TAG, "%s", header);
550 }
551 }
552
553 *pLength = length + 1;
554 return _strdup(data);
555 }
556
557 crypto_base64_decode(data, length, (BYTE**)&decoded, &decoded_length);
558 if (!decoded || decoded_length == 0)
559 {
560 WLog_ERR(TAG, "Failed to decode base64 data of length %" PRIuz " for %s", length, name);
561 zfree(decoded);
562 return nullptr;
563 }
564
565 *pLength = strnlen(decoded, decoded_length) + 1;
566 return decoded;
567}
568
569WINPR_ATTR_NODISCARD
570static BOOL pf_config_load_certificates(wIniFile* ini, proxyConfig* config)
571{
572 const char* tmp1 = nullptr;
573 const char* tmp2 = nullptr;
574
575 WINPR_ASSERT(ini);
576 WINPR_ASSERT(config);
577
578 tmp1 = pf_config_get_str(ini, section_certificates, key_cert_file, FALSE);
579 if (tmp1)
580 {
581 if (!winpr_PathFileExists(tmp1))
582 {
583 WLog_ERR(TAG, "%s/%s file %s does not exist", section_certificates, key_cert_file,
584 tmp1);
585 return FALSE;
586 }
587 config->CertificateFile = _strdup(tmp1);
588 config->CertificatePEM =
589 crypto_read_pem(config->CertificateFile, &config->CertificatePEMLength);
590 if (!config->CertificatePEM)
591 return FALSE;
592 config->CertificatePEMLength += 1;
593 }
594 tmp2 = pf_config_get_str(ini, section_certificates, key_cert_content, FALSE);
595 if (tmp2)
596 {
597 if (strlen(tmp2) < 1)
598 {
599 WLog_ERR(TAG, "%s/%s has invalid empty value", section_certificates, key_cert_content);
600 return FALSE;
601 }
602 config->CertificateContent = _strdup(tmp2);
603 config->CertificatePEM = pf_config_decode_base64(
604 config->CertificateContent, "CertificateContent", &config->CertificatePEMLength);
605 if (!config->CertificatePEM)
606 return FALSE;
607 }
608 if (tmp1 && tmp2)
609 {
610 WLog_ERR(TAG,
611 "%s/%s and %s/%s are "
612 "mutually exclusive options",
613 section_certificates, key_cert_file, section_certificates, key_cert_content);
614 return FALSE;
615 }
616 else if (!tmp1 && !tmp2)
617 {
618 WLog_ERR(TAG,
619 "%s/%s or %s/%s are "
620 "required settings",
621 section_certificates, key_cert_file, section_certificates, key_cert_content);
622 return FALSE;
623 }
624
625 tmp1 = pf_config_get_str(ini, section_certificates, key_private_key_file, FALSE);
626 if (tmp1)
627 {
628 if (!winpr_PathFileExists(tmp1))
629 {
630 WLog_ERR(TAG, "%s/%s file %s does not exist", section_certificates,
631 key_private_key_file, tmp1);
632 return FALSE;
633 }
634 config->PrivateKeyFile = _strdup(tmp1);
635 config->PrivateKeyPEM =
636 crypto_read_pem(config->PrivateKeyFile, &config->PrivateKeyPEMLength);
637 if (!config->PrivateKeyPEM)
638 return FALSE;
639 config->PrivateKeyPEMLength += 1;
640 }
641 tmp2 = pf_config_get_str(ini, section_certificates, key_private_key_content, FALSE);
642 if (tmp2)
643 {
644 if (strlen(tmp2) < 1)
645 {
646 WLog_ERR(TAG, "%s/%s has invalid empty value", section_certificates,
647 key_private_key_content);
648 return FALSE;
649 }
650 config->PrivateKeyContent = _strdup(tmp2);
651 config->PrivateKeyPEM = pf_config_decode_base64(
652 config->PrivateKeyContent, "PrivateKeyContent", &config->PrivateKeyPEMLength);
653 if (!config->PrivateKeyPEM)
654 return FALSE;
655 }
656
657 if (tmp1 && tmp2)
658 {
659 WLog_ERR(TAG,
660 "%s/%s and %s/%s are "
661 "mutually exclusive options",
662 section_certificates, key_private_key_file, section_certificates,
663 key_private_key_content);
664 return FALSE;
665 }
666 else if (!tmp1 && !tmp2)
667 {
668 WLog_ERR(TAG,
669 "%s/%s or %s/%s are "
670 "are required settings",
671 section_certificates, key_private_key_file, section_certificates,
672 key_private_key_content);
673 return FALSE;
674 }
675
676 return TRUE;
677}
678
679proxyConfig* server_config_load_ini(wIniFile* ini)
680{
681 proxyConfig* config = nullptr;
682
683 WINPR_ASSERT(ini);
684
685 config = calloc(1, sizeof(proxyConfig));
686 if (config)
687 {
688 /* Set default values != 0 */
689 config->TargetTlsSecLevel = 1;
690
691 /* Load from ini */
692 if (!pf_config_load_server(ini, config))
693 goto out;
694
695 if (!pf_config_load_target(ini, config))
696 goto out;
697
698 if (!pf_config_load_codecs(ini, config))
699 goto out;
700
701 if (!pf_config_load_channels(ini, config))
702 goto out;
703
704 if (!pf_config_load_input(ini, config))
705 goto out;
706
707 if (!pf_config_load_security(ini, config))
708 goto out;
709
710 if (!pf_config_load_modules(ini, config))
711 goto out;
712
713 if (!pf_config_load_certificates(ini, config))
714 goto out;
715 config->ini = IniFile_Clone(ini);
716 if (!config->ini)
717 goto out;
718 }
719 return config;
720out:
721 WINPR_PRAGMA_DIAG_PUSH
722 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
723 pf_server_config_free(config);
724 WINPR_PRAGMA_DIAG_POP
725
726 return nullptr;
727}
728
729BOOL pf_server_config_dump(const char* file)
730{
731 BOOL rc = FALSE;
732 wIniFile* ini = IniFile_New();
733 if (!ini)
734 return FALSE;
735
736 /* Proxy server configuration */
737 if (IniFile_SetKeyValueString(ini, section_server, key_host, "0.0.0.0") < 0)
738 goto fail;
739 if (IniFile_SetKeyValueInt(ini, section_server, key_port, 3389) < 0)
740 goto fail;
741 if (IniFile_SetKeyValueString(ini, section_server, key_sam_file,
742 "optional/path/some/file.sam") < 0)
743 goto fail;
744
745 /* Target configuration */
746 if (IniFile_SetKeyValueString(ini, section_target, key_host, "somehost.example.com") < 0)
747 goto fail;
748 if (IniFile_SetKeyValueInt(ini, section_target, key_port, 3389) < 0)
749 goto fail;
750 if (IniFile_SetKeyValueString(ini, section_target, key_target_fixed, bool_str_true) < 0)
751 goto fail;
752 if (IniFile_SetKeyValueInt(ini, section_target, key_target_tls_seclevel, 1) < 0)
753 goto fail;
754 if (IniFile_SetKeyValueString(ini, section_target, key_target_user, "optionaltargetuser") < 0)
755 goto fail;
756 if (IniFile_SetKeyValueString(ini, section_target, key_target_domain, "optionaltargetdomain") <
757 0)
758 goto fail;
759 if (IniFile_SetKeyValueString(ini, section_target, key_target_pwd, "optionaltargetpassword") <
760 0)
761 goto fail;
762 if (IniFile_SetKeyValueString(ini, section_target, key_target_scard_auth, bool_str_false) < 0)
763 goto fail;
764 if (IniFile_SetKeyValueString(ini, section_target, key_target_scard_cert,
765 "optional/path/some/file.pem.crt") < 0)
766 goto fail;
767 if (IniFile_SetKeyValueString(ini, section_target, key_target_scard_pem_cert,
768 "<base64 encoded PEM>") < 0)
769 goto fail;
770 if (IniFile_SetKeyValueString(ini, section_target, key_target_scard_key,
771 "optional/path/some/file.pem.key") < 0)
772 goto fail;
773
774 if (IniFile_SetKeyValueString(ini, section_target, key_target_scard_pem_key,
775 "<base64 encoded PEM>") < 0)
776 goto fail;
777 /* Codec configuration */
778 if (IniFile_SetKeyValueString(ini, section_codecs, key_codecs_rfx, bool_str_true) < 0)
779 goto fail;
780 if (IniFile_SetKeyValueString(ini, section_codecs, key_codecs_nsc, bool_str_true) < 0)
781 goto fail;
782
783 /* Channel configuration */
784 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_gfx, bool_str_true) < 0)
785 goto fail;
786 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_disp, bool_str_true) < 0)
787 goto fail;
788 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_clip, bool_str_true) < 0)
789 goto fail;
790 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_mic, bool_str_true) < 0)
791 goto fail;
792 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_sound, bool_str_true) < 0)
793 goto fail;
794 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_rdpdr, bool_str_true) < 0)
795 goto fail;
796 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_video, bool_str_true) < 0)
797 goto fail;
798 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_camera, bool_str_true) < 0)
799 goto fail;
800 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_rails, bool_str_false) < 0)
801 goto fail;
802
803 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_blacklist, bool_str_true) < 0)
804 goto fail;
805 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_pass, "") < 0)
806 goto fail;
807 if (IniFile_SetKeyValueString(ini, section_channels, key_channels_intercept, "") < 0)
808 goto fail;
809
810 /* Input configuration */
811 if (IniFile_SetKeyValueString(ini, section_input, key_input_kbd, bool_str_true) < 0)
812 goto fail;
813 if (IniFile_SetKeyValueString(ini, section_input, key_input_mouse, bool_str_true) < 0)
814 goto fail;
815 if (IniFile_SetKeyValueString(ini, section_input, key_input_multitouch, bool_str_true) < 0)
816 goto fail;
817
818 /* Security settings */
819 if (IniFile_SetKeyValueString(ini, section_security, key_security_server_tls, bool_str_true) <
820 0)
821 goto fail;
822 if (IniFile_SetKeyValueString(ini, section_security, key_security_server_nla, bool_str_false) <
823 0)
824 goto fail;
825 if (IniFile_SetKeyValueString(ini, section_security, key_security_server_rdp, bool_str_true) <
826 0)
827 goto fail;
828
829 if (IniFile_SetKeyValueString(ini, section_security, key_security_client_tls, bool_str_true) <
830 0)
831 goto fail;
832 if (IniFile_SetKeyValueString(ini, section_security, key_security_client_nla, bool_str_true) <
833 0)
834 goto fail;
835 if (IniFile_SetKeyValueString(ini, section_security, key_security_client_rdp, bool_str_true) <
836 0)
837 goto fail;
838 if (IniFile_SetKeyValueString(ini, section_security, key_security_client_fallback,
839 bool_str_true) < 0)
840 goto fail;
841
842 /* Module configuration */
843 if (IniFile_SetKeyValueString(ini, section_plugins, key_plugins_modules,
844 "module1,module2,...") < 0)
845 goto fail;
846 if (IniFile_SetKeyValueString(ini, section_plugins, key_plugins_required,
847 "module1,module2,...") < 0)
848 goto fail;
849
850 /* Certificate configuration */
851 if (IniFile_SetKeyValueString(ini, section_certificates, key_cert_file,
852 "<absolute path to some certificate file> OR") < 0)
853 goto fail;
854 if (IniFile_SetKeyValueString(ini, section_certificates, key_cert_content,
855 "<base64 encoded PEM>") < 0)
856 goto fail;
857
858 if (IniFile_SetKeyValueString(ini, section_certificates, key_private_key_file,
859 "<absolute path to some private key file> OR") < 0)
860 goto fail;
861 if (IniFile_SetKeyValueString(ini, section_certificates, key_private_key_content,
862 "<base64 encoded PEM>") < 0)
863 goto fail;
864
865 if ((strcmp("stdout", file) == 0) || (strcmp("stderr", file) == 0))
866 {
867 char* buffer = IniFile_WriteBuffer(ini);
868 if (!buffer)
869 goto fail;
870 FILE* fp = stderr;
871 if (strcmp("stdout", file) == 0)
872 fp = stdout;
873 (void)fprintf(fp, "%s", buffer);
874 zfree(buffer);
875 }
876 else
877 {
878 /* store configuration */
879 if (IniFile_WriteFile(ini, file) < 0)
880 goto fail;
881 }
882
883 rc = TRUE;
884
885fail:
886 IniFile_Free(ini);
887 return rc;
888}
889
890proxyConfig* pf_server_config_load_buffer(const char* buffer)
891{
892 proxyConfig* config = nullptr;
893 wIniFile* ini = nullptr;
894
895 ini = IniFile_New();
896
897 if (!ini)
898 {
899 WLog_ERR(TAG, "IniFile_New() failed!");
900 return nullptr;
901 }
902
903 if (IniFile_ReadBuffer(ini, buffer) < 0)
904 {
905 WLog_ERR(TAG, "failed to parse ini: '%s'", buffer);
906 goto out;
907 }
908
909 config = server_config_load_ini(ini);
910out:
911 IniFile_Free(ini);
912 return config;
913}
914
915proxyConfig* pf_server_config_load_file(const char* path)
916{
917 proxyConfig* config = nullptr;
918 wIniFile* ini = IniFile_New();
919
920 if (!ini)
921 {
922 WLog_ERR(TAG, "IniFile_New() failed!");
923 return nullptr;
924 }
925
926 if (IniFile_ReadFile(ini, path) < 0)
927 {
928 WLog_ERR(TAG, "failed to parse ini file: '%s'", path);
929 goto out;
930 }
931
932 config = server_config_load_ini(ini);
933out:
934 IniFile_Free(ini);
935 return config;
936}
937
938static void pf_server_config_print_list(char** list, size_t count)
939{
940 WINPR_ASSERT(list);
941 for (size_t i = 0; i < count; i++)
942 WLog_INFO(TAG, "\t\t- %s", list[i]);
943}
944
945void pf_server_config_print(const proxyConfig* config)
946{
947 WINPR_ASSERT(config);
948 WLog_INFO(TAG, "Proxy configuration:");
949
950 CONFIG_PRINT_SECTION(section_server);
951 CONFIG_PRINT_STR(config, Host);
952 CONFIG_PRINT_STR(config, SamFile);
953 CONFIG_PRINT_UINT16(config, Port);
954
955 if (config->FixedTarget)
956 {
957 CONFIG_PRINT_SECTION(section_target);
958 CONFIG_PRINT_STR(config, TargetHost);
959 CONFIG_PRINT_UINT16(config, TargetPort);
960 CONFIG_PRINT_UINT32(config, TargetTlsSecLevel);
961
962 CONFIG_PRINT_STR(config, TargetUser);
963 CONFIG_PRINT_STR(config, TargetDomain);
964 CONFIG_PRINT_SECRET_STR(config, TargetPassword);
965
966 CONFIG_PRINT_BOOL(config, TargetSmartcardAuth);
967 CONFIG_PRINT_SECRET_STR(config, TargetSmartcardCert);
968 CONFIG_PRINT_SECRET_STR(config, TargetSmartcardKey);
969 }
970
971 CONFIG_PRINT_SECTION(section_input);
972 CONFIG_PRINT_BOOL(config, Keyboard);
973 CONFIG_PRINT_BOOL(config, Mouse);
974 CONFIG_PRINT_BOOL(config, Multitouch);
975
976 CONFIG_PRINT_SECTION(section_security);
977 CONFIG_PRINT_BOOL(config, ServerNlaSecurity);
978 CONFIG_PRINT_BOOL(config, ServerTlsSecurity);
979 CONFIG_PRINT_BOOL(config, ServerRdpSecurity);
980 CONFIG_PRINT_BOOL(config, ClientNlaSecurity);
981 CONFIG_PRINT_BOOL(config, ClientTlsSecurity);
982 CONFIG_PRINT_BOOL(config, ClientRdpSecurity);
983 CONFIG_PRINT_BOOL(config, ClientAllowFallbackToTls);
984
985 CONFIG_PRINT_SECTION(section_codecs);
986 CONFIG_PRINT_BOOL(config, RFX);
987 CONFIG_PRINT_BOOL(config, NSC);
988
989 CONFIG_PRINT_SECTION(section_channels);
990 CONFIG_PRINT_BOOL(config, GFX);
991 CONFIG_PRINT_BOOL(config, DisplayControl);
992 CONFIG_PRINT_BOOL(config, Clipboard);
993 CONFIG_PRINT_BOOL(config, AudioOutput);
994 CONFIG_PRINT_BOOL(config, AudioInput);
995 CONFIG_PRINT_BOOL(config, DeviceRedirection);
996 CONFIG_PRINT_BOOL(config, VideoRedirection);
997 CONFIG_PRINT_BOOL(config, CameraRedirection);
998 CONFIG_PRINT_BOOL(config, RemoteApp);
999 CONFIG_PRINT_BOOL(config, PassthroughIsBlacklist);
1000
1001 if (config->PassthroughCount)
1002 {
1003 WLog_INFO(TAG, "\tStatic Channels Proxy:");
1004 pf_server_config_print_list(config->Passthrough, config->PassthroughCount);
1005 }
1006
1007 if (config->InterceptCount)
1008 {
1009 WLog_INFO(TAG, "\tStatic Channels Proxy-Intercept:");
1010 pf_server_config_print_list(config->Intercept, config->InterceptCount);
1011 }
1012
1013 /* modules */
1014 CONFIG_PRINT_SECTION_KEY(section_plugins, key_plugins_modules);
1015 for (size_t x = 0; x < config->ModulesCount; x++)
1016 CONFIG_PRINT_STR(config, Modules[x]);
1017
1018 /* Required plugins */
1019 CONFIG_PRINT_SECTION_KEY(section_plugins, key_plugins_required);
1020 for (size_t x = 0; x < config->RequiredPluginsCount; x++)
1021 CONFIG_PRINT_STR(config, RequiredPlugins[x]);
1022
1023 CONFIG_PRINT_SECTION(section_certificates);
1024 CONFIG_PRINT_STR(config, CertificateFile);
1025 CONFIG_PRINT_SECRET_STR(config, CertificateContent);
1026 CONFIG_PRINT_STR(config, PrivateKeyFile);
1027 CONFIG_PRINT_SECRET_STR(config, PrivateKeyContent);
1028}
1029
1030void pf_server_config_free(proxyConfig* config)
1031{
1032 if (config == nullptr)
1033 return;
1034
1035 zfree(config->Host);
1036 zfree(config->SamFile);
1037 zfree(config->TargetHost);
1038 zfree(config->TargetUser);
1039 zfree(config->TargetDomain);
1040 zfree(config->TargetPassword);
1041 znfree(config->TargetSmartcardCert, config->TargetSmartcardCertLength);
1042 znfree(config->TargetSmartcardKey, config->TargetSmartcardKeyLength);
1043
1044 CommandLineParserFree(config->Passthrough);
1045 CommandLineParserFree(config->Intercept);
1046 CommandLineParserFree(config->Modules);
1047 CommandLineParserFree(config->RequiredPlugins);
1048
1049 zfree(config->CertificateFile);
1050 zfree(config->CertificateContent);
1051 znfree(config->CertificatePEM, config->CertificatePEMLength);
1052 zfree(config->PrivateKeyFile);
1053 zfree(config->PrivateKeyContent);
1054 znfree(config->PrivateKeyPEM, config->PrivateKeyPEMLength);
1055 IniFile_Free(config->ini);
1056 free(config);
1057}
1058
1059size_t pf_config_required_plugins_count(const proxyConfig* config)
1060{
1061 WINPR_ASSERT(config);
1062 return config->RequiredPluginsCount;
1063}
1064
1065const char* pf_config_required_plugin(const proxyConfig* config, size_t index)
1066{
1067 WINPR_ASSERT(config);
1068 if (index >= config->RequiredPluginsCount)
1069 return nullptr;
1070
1071 return config->RequiredPlugins[index];
1072}
1073
1074size_t pf_config_modules_count(const proxyConfig* config)
1075{
1076 WINPR_ASSERT(config);
1077 return config->ModulesCount;
1078}
1079
1080const char** pf_config_modules(const proxyConfig* config)
1081{
1082 union
1083 {
1084 char** ppc;
1085 const char** cppc;
1086 } cnv;
1087
1088 WINPR_ASSERT(config);
1089
1090 cnv.ppc = config->Modules;
1091 return cnv.cppc;
1092}
1093
1094WINPR_ATTR_NODISCARD
1095static BOOL pf_config_copy_string_n(char** dst, const char* src, size_t size)
1096{
1097 *dst = nullptr;
1098
1099 if (src && (size > 0))
1100 {
1101 WINPR_ASSERT(strnlen(src, size) == size - 1);
1102 *dst = calloc(size, sizeof(char));
1103 if (!*dst)
1104 return FALSE;
1105 memcpy(*dst, src, size);
1106 }
1107
1108 return TRUE;
1109}
1110
1111WINPR_ATTR_NODISCARD
1112static BOOL pf_config_copy_string_list(char*** dst, size_t* size, char** src, size_t srcSize)
1113{
1114 WINPR_ASSERT(dst);
1115 WINPR_ASSERT(size);
1116 WINPR_ASSERT(src || (srcSize == 0));
1117
1118 *dst = nullptr;
1119 *size = 0;
1120 if (srcSize > INT32_MAX)
1121 return FALSE;
1122
1123 if (srcSize != 0)
1124 {
1125 char* csv = CommandLineToCommaSeparatedValues((INT32)srcSize, src);
1126 *dst = CommandLineParseCommaSeparatedValues(csv, size);
1127 zfree(csv);
1128 }
1129
1130 return TRUE;
1131}
1132
1133BOOL pf_config_clone(proxyConfig** dst, const proxyConfig* config)
1134{
1135 proxyConfig* tmp = calloc(1, sizeof(proxyConfig));
1136
1137 WINPR_ASSERT(dst);
1138 WINPR_ASSERT(config);
1139
1140 if (!tmp)
1141 return FALSE;
1142
1143 *tmp = *config;
1144
1145 if (!pf_config_copy_string(&tmp->Host, config->Host))
1146 goto fail;
1147 if (!pf_config_copy_string(&tmp->SamFile, config->SamFile))
1148 goto fail;
1149 if (!pf_config_copy_string(&tmp->TargetHost, config->TargetHost))
1150 goto fail;
1151 if (!pf_config_copy_string(&tmp->TargetUser, config->TargetUser))
1152 goto fail;
1153 if (!pf_config_copy_string(&tmp->TargetDomain, config->TargetDomain))
1154 goto fail;
1155 if (!pf_config_copy_string(&tmp->TargetPassword, config->TargetPassword))
1156 goto fail;
1157 if (!pf_config_copy_string_n(&tmp->TargetSmartcardCert, config->TargetSmartcardCert,
1158 config->TargetSmartcardCertLength))
1159 goto fail;
1160 if (!pf_config_copy_string_n(&tmp->TargetSmartcardKey, config->TargetSmartcardKey,
1161 config->TargetSmartcardKeyLength))
1162 goto fail;
1163 if (!pf_config_copy_string_list(&tmp->Passthrough, &tmp->PassthroughCount, config->Passthrough,
1164 config->PassthroughCount))
1165 goto fail;
1166 if (!pf_config_copy_string_list(&tmp->Intercept, &tmp->InterceptCount, config->Intercept,
1167 config->InterceptCount))
1168 goto fail;
1169 if (!pf_config_copy_string_list(&tmp->Modules, &tmp->ModulesCount, config->Modules,
1170 config->ModulesCount))
1171 goto fail;
1172 if (!pf_config_copy_string_list(&tmp->RequiredPlugins, &tmp->RequiredPluginsCount,
1173 config->RequiredPlugins, config->RequiredPluginsCount))
1174 goto fail;
1175 if (!pf_config_copy_string(&tmp->CertificateFile, config->CertificateFile))
1176 goto fail;
1177 if (!pf_config_copy_string(&tmp->CertificateContent, config->CertificateContent))
1178 goto fail;
1179 if (!pf_config_copy_string_n(&tmp->CertificatePEM, config->CertificatePEM,
1180 config->CertificatePEMLength))
1181 goto fail;
1182 if (!pf_config_copy_string(&tmp->PrivateKeyFile, config->PrivateKeyFile))
1183 goto fail;
1184 if (!pf_config_copy_string(&tmp->PrivateKeyContent, config->PrivateKeyContent))
1185 goto fail;
1186 if (!pf_config_copy_string_n(&tmp->PrivateKeyPEM, config->PrivateKeyPEM,
1187 config->PrivateKeyPEMLength))
1188 goto fail;
1189
1190 tmp->ini = IniFile_Clone(config->ini);
1191 if (!tmp->ini)
1192 goto fail;
1193
1194 *dst = tmp;
1195 return TRUE;
1196
1197fail:
1198 WINPR_PRAGMA_DIAG_PUSH
1199 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1200 pf_server_config_free(tmp);
1201 WINPR_PRAGMA_DIAG_POP
1202 return FALSE;
1203}
1204
1205struct config_plugin_data
1206{
1207 proxyPluginsManager* mgr;
1208 const proxyConfig* config;
1209};
1210
1211static const char config_plugin_name[] = "config";
1212static const char config_plugin_desc[] =
1213 "A plugin filtering according to proxy configuration file rules";
1214
1215WINPR_ATTR_NODISCARD
1216static BOOL config_plugin_unload(proxyPlugin* plugin)
1217{
1218 WINPR_ASSERT(plugin);
1219
1220 /* Here we have to free up our custom data storage. */
1221 if (plugin)
1222 {
1223 free(plugin->custom);
1224 plugin->custom = nullptr;
1225 }
1226
1227 return TRUE;
1228}
1229
1230WINPR_ATTR_NODISCARD
1231static BOOL config_plugin_keyboard_event(proxyPlugin* plugin, WINPR_ATTR_UNUSED proxyData* pdata,
1232 void* param)
1233{
1234 BOOL rc = 0;
1235 const struct config_plugin_data* custom = nullptr;
1236 const proxyConfig* cfg = nullptr;
1237 const proxyKeyboardEventInfo* event_data = (const proxyKeyboardEventInfo*)(param);
1238
1239 WINPR_ASSERT(plugin);
1240 WINPR_ASSERT(pdata);
1241 WINPR_ASSERT(event_data);
1242
1243 WINPR_UNUSED(event_data);
1244
1245 custom = plugin->custom;
1246 WINPR_ASSERT(custom);
1247
1248 cfg = custom->config;
1249 WINPR_ASSERT(cfg);
1250
1251 rc = cfg->Keyboard;
1252 WLog_DBG(TAG, "%s", boolstr(rc));
1253 return rc;
1254}
1255
1256WINPR_ATTR_NODISCARD
1257static BOOL config_plugin_unicode_event(proxyPlugin* plugin, WINPR_ATTR_UNUSED proxyData* pdata,
1258 void* param)
1259{
1260 BOOL rc = 0;
1261 const struct config_plugin_data* custom = nullptr;
1262 const proxyConfig* cfg = nullptr;
1263 const proxyUnicodeEventInfo* event_data = (const proxyUnicodeEventInfo*)(param);
1264
1265 WINPR_ASSERT(plugin);
1266 WINPR_ASSERT(pdata);
1267 WINPR_ASSERT(event_data);
1268
1269 WINPR_UNUSED(event_data);
1270
1271 custom = plugin->custom;
1272 WINPR_ASSERT(custom);
1273
1274 cfg = custom->config;
1275 WINPR_ASSERT(cfg);
1276
1277 rc = cfg->Keyboard;
1278 WLog_DBG(TAG, "%s", boolstr(rc));
1279 return rc;
1280}
1281
1282WINPR_ATTR_NODISCARD
1283static BOOL config_plugin_mouse_event(proxyPlugin* plugin, WINPR_ATTR_UNUSED proxyData* pdata,
1284 void* param)
1285{
1286 BOOL rc = 0;
1287 const struct config_plugin_data* custom = nullptr;
1288 const proxyConfig* cfg = nullptr;
1289 const proxyMouseEventInfo* event_data = (const proxyMouseEventInfo*)(param);
1290
1291 WINPR_ASSERT(plugin);
1292 WINPR_ASSERT(pdata);
1293 WINPR_ASSERT(event_data);
1294
1295 WINPR_UNUSED(event_data);
1296
1297 custom = plugin->custom;
1298 WINPR_ASSERT(custom);
1299
1300 cfg = custom->config;
1301 WINPR_ASSERT(cfg);
1302
1303 rc = cfg->Mouse;
1304 return rc;
1305}
1306
1307WINPR_ATTR_NODISCARD
1308static BOOL config_plugin_mouse_ex_event(proxyPlugin* plugin, WINPR_ATTR_UNUSED proxyData* pdata,
1309 void* param)
1310{
1311 BOOL rc = 0;
1312 const struct config_plugin_data* custom = nullptr;
1313 const proxyConfig* cfg = nullptr;
1314 const proxyMouseExEventInfo* event_data = (const proxyMouseExEventInfo*)(param);
1315
1316 WINPR_ASSERT(plugin);
1317 WINPR_ASSERT(pdata);
1318 WINPR_ASSERT(event_data);
1319
1320 WINPR_UNUSED(event_data);
1321
1322 custom = plugin->custom;
1323 WINPR_ASSERT(custom);
1324
1325 cfg = custom->config;
1326 WINPR_ASSERT(cfg);
1327
1328 rc = cfg->Mouse;
1329 return rc;
1330}
1331
1332WINPR_ATTR_NODISCARD
1333static BOOL config_plugin_client_channel_data(WINPR_ATTR_UNUSED proxyPlugin* plugin,
1334 WINPR_ATTR_UNUSED proxyData* pdata, void* param)
1335{
1336 const proxyChannelDataEventInfo* channel = (const proxyChannelDataEventInfo*)(param);
1337
1338 WINPR_ASSERT(plugin);
1339 WINPR_ASSERT(pdata);
1340 WINPR_ASSERT(channel);
1341
1342 WLog_DBG(TAG, "%s [0x%04" PRIx16 "] got %" PRIuz, channel->channel_name, channel->channel_id,
1343 channel->data_len);
1344 return TRUE;
1345}
1346
1347WINPR_ATTR_NODISCARD
1348static BOOL config_plugin_server_channel_data(WINPR_ATTR_UNUSED proxyPlugin* plugin,
1349 WINPR_ATTR_UNUSED proxyData* pdata, void* param)
1350{
1351 const proxyChannelDataEventInfo* channel = (const proxyChannelDataEventInfo*)(param);
1352
1353 WINPR_ASSERT(plugin);
1354 WINPR_ASSERT(pdata);
1355 WINPR_ASSERT(channel);
1356
1357 WLog_DBG(TAG, "%s [0x%04" PRIx16 "] got %" PRIuz, channel->channel_name, channel->channel_id,
1358 channel->data_len);
1359 return TRUE;
1360}
1361
1362WINPR_ATTR_NODISCARD
1363static BOOL config_plugin_dynamic_channel_create(proxyPlugin* plugin,
1364 WINPR_ATTR_UNUSED proxyData* pdata, void* param)
1365{
1366 BOOL accept = 0;
1367 const proxyChannelDataEventInfo* channel = (const proxyChannelDataEventInfo*)(param);
1368
1369 WINPR_ASSERT(plugin);
1370 WINPR_ASSERT(pdata);
1371 WINPR_ASSERT(channel);
1372
1373 const struct config_plugin_data* custom = plugin->custom;
1374 WINPR_ASSERT(custom);
1375
1376 const proxyConfig* cfg = custom->config;
1377 WINPR_ASSERT(cfg);
1378
1379 pf_utils_channel_mode rc = pf_utils_get_channel_mode(cfg, channel->channel_name);
1380 switch (rc)
1381 {
1382
1383 case PF_UTILS_CHANNEL_INTERCEPT:
1384 case PF_UTILS_CHANNEL_PASSTHROUGH:
1385 accept = TRUE;
1386 break;
1387 case PF_UTILS_CHANNEL_BLOCK:
1388 default:
1389 accept = FALSE;
1390 break;
1391 }
1392
1393 if (accept)
1394 {
1395 if (strncmp(RDPGFX_DVC_CHANNEL_NAME, channel->channel_name,
1396 sizeof(RDPGFX_DVC_CHANNEL_NAME)) == 0)
1397 accept = cfg->GFX;
1398 else if (strncmp(RDPSND_DVC_CHANNEL_NAME, channel->channel_name,
1399 sizeof(RDPSND_DVC_CHANNEL_NAME)) == 0)
1400 accept = cfg->AudioOutput;
1401 else if (strncmp(RDPSND_LOSSY_DVC_CHANNEL_NAME, channel->channel_name,
1402 sizeof(RDPSND_LOSSY_DVC_CHANNEL_NAME)) == 0)
1403 accept = cfg->AudioOutput;
1404 else if (strncmp(AUDIN_DVC_CHANNEL_NAME, channel->channel_name,
1405 sizeof(AUDIN_DVC_CHANNEL_NAME)) == 0)
1406 accept = cfg->AudioInput;
1407 else if (strncmp(RDPEI_DVC_CHANNEL_NAME, channel->channel_name,
1408 sizeof(RDPEI_DVC_CHANNEL_NAME)) == 0)
1409 accept = cfg->Multitouch;
1410 else if (strncmp(TSMF_DVC_CHANNEL_NAME, channel->channel_name,
1411 sizeof(TSMF_DVC_CHANNEL_NAME)) == 0)
1412 accept = cfg->VideoRedirection;
1413 else if (strncmp(VIDEO_CONTROL_DVC_CHANNEL_NAME, channel->channel_name,
1414 sizeof(VIDEO_CONTROL_DVC_CHANNEL_NAME)) == 0)
1415 accept = cfg->VideoRedirection;
1416 else if (strncmp(VIDEO_DATA_DVC_CHANNEL_NAME, channel->channel_name,
1417 sizeof(VIDEO_DATA_DVC_CHANNEL_NAME)) == 0)
1418 accept = cfg->VideoRedirection;
1419 else if (strncmp(RDPECAM_DVC_CHANNEL_NAME, channel->channel_name,
1420 sizeof(RDPECAM_DVC_CHANNEL_NAME)) == 0)
1421 accept = cfg->CameraRedirection;
1422 }
1423
1424 WLog_DBG(TAG, "%s [0x%04" PRIx16 "]: %s", channel->channel_name, channel->channel_id,
1425 boolstr(accept));
1426 return accept;
1427}
1428
1429WINPR_ATTR_NODISCARD
1430static BOOL config_plugin_channel_create(proxyPlugin* plugin, WINPR_ATTR_UNUSED proxyData* pdata,
1431 void* param)
1432{
1433 BOOL accept = 0;
1434 const proxyChannelDataEventInfo* channel = (const proxyChannelDataEventInfo*)(param);
1435
1436 WINPR_ASSERT(plugin);
1437 WINPR_ASSERT(pdata);
1438 WINPR_ASSERT(channel);
1439
1440 const struct config_plugin_data* custom = plugin->custom;
1441 WINPR_ASSERT(custom);
1442
1443 const proxyConfig* cfg = custom->config;
1444 WINPR_ASSERT(cfg);
1445
1446 pf_utils_channel_mode rc = pf_utils_get_channel_mode(cfg, channel->channel_name);
1447 switch (rc)
1448 {
1449 case PF_UTILS_CHANNEL_INTERCEPT:
1450 case PF_UTILS_CHANNEL_PASSTHROUGH:
1451 accept = TRUE;
1452 break;
1453 case PF_UTILS_CHANNEL_BLOCK:
1454 default:
1455 accept = FALSE;
1456 break;
1457 }
1458 if (accept)
1459 {
1460 if (strncmp(CLIPRDR_SVC_CHANNEL_NAME, channel->channel_name,
1461 sizeof(CLIPRDR_SVC_CHANNEL_NAME)) == 0)
1462 accept = cfg->Clipboard;
1463 else if (strncmp(RDPSND_CHANNEL_NAME, channel->channel_name, sizeof(RDPSND_CHANNEL_NAME)) ==
1464 0)
1465 accept = cfg->AudioOutput;
1466 else if (strncmp(RDPDR_SVC_CHANNEL_NAME, channel->channel_name,
1467 sizeof(RDPDR_SVC_CHANNEL_NAME)) == 0)
1468 accept = cfg->DeviceRedirection;
1469 else if (strncmp(DISP_DVC_CHANNEL_NAME, channel->channel_name,
1470 sizeof(DISP_DVC_CHANNEL_NAME)) == 0)
1471 accept = cfg->DisplayControl;
1472 else if (strncmp(RAIL_SVC_CHANNEL_NAME, channel->channel_name,
1473 sizeof(RAIL_SVC_CHANNEL_NAME)) == 0)
1474 accept = cfg->RemoteApp;
1475 }
1476
1477 WLog_DBG(TAG, "%s [static]: %s", channel->channel_name, boolstr(accept));
1478 return accept;
1479}
1480
1481BOOL pf_config_plugin(proxyPluginsManager* plugins_manager, void* userdata)
1482{
1483 struct config_plugin_data* custom = nullptr;
1484 proxyPlugin plugin = WINPR_C_ARRAY_INIT;
1485
1486 plugin.name = config_plugin_name;
1487 plugin.description = config_plugin_desc;
1488 plugin.PluginUnload = config_plugin_unload;
1489
1490 plugin.KeyboardEvent = config_plugin_keyboard_event;
1491 plugin.UnicodeEvent = config_plugin_unicode_event;
1492 plugin.MouseEvent = config_plugin_mouse_event;
1493 plugin.MouseExEvent = config_plugin_mouse_ex_event;
1494 plugin.ClientChannelData = config_plugin_client_channel_data;
1495 plugin.ServerChannelData = config_plugin_server_channel_data;
1496 plugin.ChannelCreate = config_plugin_channel_create;
1497 plugin.DynamicChannelCreate = config_plugin_dynamic_channel_create;
1498 plugin.userdata = userdata;
1499
1500 custom = calloc(1, sizeof(struct config_plugin_data));
1501 if (!custom)
1502 return FALSE;
1503
1504 custom->mgr = plugins_manager;
1505 custom->config = userdata;
1506
1507 plugin.custom = custom;
1508 plugin.userdata = userdata;
1509
1510 return plugins_manager->RegisterPlugin(plugins_manager, &plugin);
1511}
1512
1513const char* pf_config_get(const proxyConfig* config, const char* section, const char* key)
1514{
1515 WINPR_ASSERT(config);
1516 WINPR_ASSERT(config->ini);
1517 WINPR_ASSERT(section);
1518 WINPR_ASSERT(key);
1519
1520 return IniFile_GetKeyValueString(config->ini, section, key);
1521}
pf_server_config_load_buffer
proxyConfig * pf_server_config_load_buffer(const char *buffer)
pf_server_config_load_buffer Create a proxyConfig from a memory string buffer in INI file format
Definition pf_config.c:890
pf_server_config_free
void pf_server_config_free(proxyConfig *config)
pf_server_config_free Releases all resources associated with proxyConfig
Definition pf_config.c:1030
pf_server_config_print
void pf_server_config_print(const proxyConfig *config)
pf_server_config_print Print the configuration to stdout
Definition pf_config.c:945
pf_config_modules
const char ** pf_config_modules(const proxyConfig *config)
pf_config_modules
Definition pf_config.c:1080
pf_config_required_plugin
const char * pf_config_required_plugin(const proxyConfig *config, size_t index)
pf_config_required_plugin
Definition pf_config.c:1065
pf_config_modules_count
size_t pf_config_modules_count(const proxyConfig *config)
pf_config_modules_count
Definition pf_config.c:1074
pf_config_clone
BOOL pf_config_clone(proxyConfig **dst, const proxyConfig *config)
pf_config_clone Create a copy of the configuration
Definition pf_config.c:1133
pf_config_required_plugins_count
size_t pf_config_required_plugins_count(const proxyConfig *config)
pf_config_required_plugins_count
Definition pf_config.c:1059
server_config_load_ini
proxyConfig * server_config_load_ini(wIniFile *ini)
server_config_load_ini Create a proxyConfig from a already loaded INI file.
Definition pf_config.c:679
pf_server_config_load_file
proxyConfig * pf_server_config_load_file(const char *path)
pf_server_config_load_file Create a proxyConfig from a INI file found at path.
Definition pf_config.c:915
pf_server_config_dump
BOOL pf_server_config_dump(const char *file)
pf_server_config_dump Dumps a default INI configuration file
Definition pf_config.c:729
pf_config_plugin
BOOL pf_config_plugin(proxyPluginsManager *plugins_manager, void *userdata)
pf_config_plugin Register a proxy plugin handling event filtering defined in the configuration.
Definition pf_config.c:1481
pf_config_get
const char * pf_config_get(const proxyConfig *config, const char *section, const char *key)
pf_config_get get a value for a section/key
Definition pf_config.c:1513