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