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