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