FreeRDP
Loading...
Searching...
No Matches
pf_modules.c
1
23#include <winpr/assert.h>
24
25#include <winpr/file.h>
26#include <winpr/wlog.h>
27#include <winpr/path.h>
28#include <winpr/library.h>
29
30#include <freerdp/version.h>
31#include <freerdp/api.h>
32#include <freerdp/build-config.h>
33
34#include <freerdp/server/proxy/proxy_log.h>
35#include <freerdp/server/proxy/proxy_modules_api.h>
36
37#include <freerdp/server/proxy/proxy_context.h>
38#include "proxy_modules.h"
39
40#define TAG PROXY_TAG("modules")
41
42#define MODULE_ENTRY_POINT "proxy_module_entry_point"
43
44struct proxy_module
45{
46 proxyPluginsManager mgr;
47 wArrayList* plugins;
48 wArrayList* handles;
49};
50
51WINPR_ATTR_NODISCARD
52static const char* pf_modules_get_filter_type_string(PF_FILTER_TYPE result)
53{
54 switch (result)
55 {
56 case FILTER_TYPE_KEYBOARD:
57 return "FILTER_TYPE_KEYBOARD";
58 case FILTER_TYPE_UNICODE:
59 return "FILTER_TYPE_UNICODE";
60 case FILTER_TYPE_MOUSE:
61 return "FILTER_TYPE_MOUSE";
62 case FILTER_TYPE_MOUSE_EX:
63 return "FILTER_TYPE_MOUSE_EX";
64 case FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_DATA:
65 return "FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_DATA";
66 case FILTER_TYPE_SERVER_PASSTHROUGH_CHANNEL_DATA:
67 return "FILTER_TYPE_SERVER_PASSTHROUGH_CHANNEL_DATA";
68 case FILTER_TYPE_CLIENT_PASSTHROUGH_DYN_CHANNEL_CREATE:
69 return "FILTER_TYPE_CLIENT_PASSTHROUGH_DYN_CHANNEL_CREATE";
70 case FILTER_TYPE_SERVER_FETCH_TARGET_ADDR:
71 return "FILTER_TYPE_SERVER_FETCH_TARGET_ADDR";
72 case FILTER_TYPE_SERVER_PEER_LOGON:
73 return "FILTER_TYPE_SERVER_PEER_LOGON";
74 case FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_CREATE:
75 return "FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_CREATE";
76 case FILTER_TYPE_STATIC_INTERCEPT_LIST:
77 return "FILTER_TYPE_STATIC_INTERCEPT_LIST";
78 case FILTER_TYPE_DYN_INTERCEPT_LIST:
79 return "FILTER_TYPE_DYN_INTERCEPT_LIST";
80 case FILTER_TYPE_INTERCEPT_CHANNEL:
81 return "FILTER_TYPE_INTERCEPT_CHANNEL";
82 case FILTER_LAST:
83 return "FILTER_LAST";
84 default:
85 return "FILTER_UNKNOWN";
86 }
87}
88
89WINPR_ATTR_NODISCARD
90static const char* pf_modules_get_hook_type_string(PF_HOOK_TYPE result)
91{
92 switch (result)
93 {
94 case HOOK_TYPE_CLIENT_INIT_CONNECT:
95 return "HOOK_TYPE_CLIENT_INIT_CONNECT";
96 case HOOK_TYPE_CLIENT_UNINIT_CONNECT:
97 return "HOOK_TYPE_CLIENT_UNINIT_CONNECT";
98 case HOOK_TYPE_CLIENT_PRE_CONNECT:
99 return "HOOK_TYPE_CLIENT_PRE_CONNECT";
100 case HOOK_TYPE_CLIENT_POST_CONNECT:
101 return "HOOK_TYPE_CLIENT_POST_CONNECT";
102 case HOOK_TYPE_CLIENT_POST_DISCONNECT:
103 return "HOOK_TYPE_CLIENT_POST_DISCONNECT";
104 case HOOK_TYPE_CLIENT_REDIRECT:
105 return "HOOK_TYPE_CLIENT_REDIRECT";
106 case HOOK_TYPE_CLIENT_VERIFY_X509:
107 return "HOOK_TYPE_CLIENT_VERIFY_X509";
108 case HOOK_TYPE_CLIENT_LOGIN_FAILURE:
109 return "HOOK_TYPE_CLIENT_LOGIN_FAILURE";
110 case HOOK_TYPE_CLIENT_END_PAINT:
111 return "HOOK_TYPE_CLIENT_END_PAINT";
112 case HOOK_TYPE_SERVER_POST_CONNECT:
113 return "HOOK_TYPE_SERVER_POST_CONNECT";
114 case HOOK_TYPE_SERVER_ACTIVATE:
115 return "HOOK_TYPE_SERVER_ACTIVATE";
116 case HOOK_TYPE_SERVER_CHANNELS_INIT:
117 return "HOOK_TYPE_SERVER_CHANNELS_INIT";
118 case HOOK_TYPE_SERVER_CHANNELS_FREE:
119 return "HOOK_TYPE_SERVER_CHANNELS_FREE";
120 case HOOK_TYPE_SERVER_SESSION_END:
121 return "HOOK_TYPE_SERVER_SESSION_END";
122 case HOOK_TYPE_CLIENT_LOAD_CHANNELS:
123 return "HOOK_TYPE_CLIENT_LOAD_CHANNELS";
124 case HOOK_TYPE_SERVER_SESSION_INITIALIZE:
125 return "HOOK_TYPE_SERVER_SESSION_INITIALIZE";
126 case HOOK_TYPE_SERVER_SESSION_STARTED:
127 return "HOOK_TYPE_SERVER_SESSION_STARTED";
128 case HOOK_LAST:
129 return "HOOK_LAST";
130 default:
131 return "HOOK_TYPE_UNKNOWN";
132 }
133}
134
135WINPR_ATTR_NODISCARD
136static BOOL pf_modules_proxy_ArrayList_ForEachFkt(void* data, size_t index, va_list ap)
137{
138 proxyPlugin* plugin = (proxyPlugin*)data;
139 BOOL ok = FALSE;
140
141 WINPR_UNUSED(index);
142
143 PF_HOOK_TYPE type = va_arg(ap, PF_HOOK_TYPE);
144 proxyData* pdata = va_arg(ap, proxyData*);
145 void* custom = va_arg(ap, void*);
146
147 WLog_VRB(TAG, "running hook %s.%s", plugin->name, pf_modules_get_hook_type_string(type));
148
149 switch (type)
150 {
151 case HOOK_TYPE_CLIENT_INIT_CONNECT:
152 ok = IFCALLRESULT(TRUE, plugin->ClientInitConnect, plugin, pdata, custom);
153 break;
154 case HOOK_TYPE_CLIENT_UNINIT_CONNECT:
155 ok = IFCALLRESULT(TRUE, plugin->ClientUninitConnect, plugin, pdata, custom);
156 break;
157 case HOOK_TYPE_CLIENT_PRE_CONNECT:
158 ok = IFCALLRESULT(TRUE, plugin->ClientPreConnect, plugin, pdata, custom);
159 break;
160
161 case HOOK_TYPE_CLIENT_POST_CONNECT:
162 ok = IFCALLRESULT(TRUE, plugin->ClientPostConnect, plugin, pdata, custom);
163 break;
164
165 case HOOK_TYPE_CLIENT_REDIRECT:
166 ok = IFCALLRESULT(TRUE, plugin->ClientRedirect, plugin, pdata, custom);
167 break;
168
169 case HOOK_TYPE_CLIENT_POST_DISCONNECT:
170 ok = IFCALLRESULT(TRUE, plugin->ClientPostDisconnect, plugin, pdata, custom);
171 break;
172
173 /* ClientX509Certificate callback is special. If no callback is set, tell the parent the
174 * run failed. Only on failure the rest of the certificate policy is checked. If we
175 * return success it means no more certificate checks are done.
176 */
177 case HOOK_TYPE_CLIENT_VERIFY_X509:
178 ok = IFCALLRESULT(FALSE, plugin->ClientX509Certificate, plugin, pdata, custom);
179 break;
180
181 case HOOK_TYPE_CLIENT_LOGIN_FAILURE:
182 ok = IFCALLRESULT(TRUE, plugin->ClientLoginFailure, plugin, pdata, custom);
183 break;
184
185 case HOOK_TYPE_CLIENT_END_PAINT:
186 ok = IFCALLRESULT(TRUE, plugin->ClientEndPaint, plugin, pdata, custom);
187 break;
188
189 case HOOK_TYPE_CLIENT_LOAD_CHANNELS:
190 ok = IFCALLRESULT(TRUE, plugin->ClientLoadChannels, plugin, pdata, custom);
191 break;
192
193 case HOOK_TYPE_SERVER_POST_CONNECT:
194 ok = IFCALLRESULT(TRUE, plugin->ServerPostConnect, plugin, pdata, custom);
195 break;
196
197 case HOOK_TYPE_SERVER_ACTIVATE:
198 ok = IFCALLRESULT(TRUE, plugin->ServerPeerActivate, plugin, pdata, custom);
199 break;
200
201 case HOOK_TYPE_SERVER_CHANNELS_INIT:
202 ok = IFCALLRESULT(TRUE, plugin->ServerChannelsInit, plugin, pdata, custom);
203 break;
204
205 case HOOK_TYPE_SERVER_CHANNELS_FREE:
206 ok = IFCALLRESULT(TRUE, plugin->ServerChannelsFree, plugin, pdata, custom);
207 break;
208
209 case HOOK_TYPE_SERVER_SESSION_END:
210 ok = IFCALLRESULT(TRUE, plugin->ServerSessionEnd, plugin, pdata, custom);
211 break;
212
213 case HOOK_TYPE_SERVER_SESSION_INITIALIZE:
214 ok = IFCALLRESULT(TRUE, plugin->ServerSessionInitialize, plugin, pdata, custom);
215 break;
216
217 case HOOK_TYPE_SERVER_SESSION_STARTED:
218 ok = IFCALLRESULT(TRUE, plugin->ServerSessionStarted, plugin, pdata, custom);
219 break;
220
221 case HOOK_LAST:
222 default:
223 WLog_ERR(TAG, "invalid hook called");
224 }
225
226 if (!ok)
227 {
228 WLog_INFO(TAG, "plugin %s, hook %s failed!", plugin->name,
229 pf_modules_get_hook_type_string(type));
230 return FALSE;
231 }
232 return TRUE;
233}
234
235/*
236 * runs all hooks of type `type`.
237 *
238 * @type: hook type to run.
239 * @server: pointer of server's rdpContext struct of the current session.
240 */
241BOOL pf_modules_run_hook(proxyModule* module, PF_HOOK_TYPE type, proxyData* pdata, void* custom)
242{
243 WINPR_ASSERT(module);
244 WINPR_ASSERT(module->plugins);
245 return ArrayList_ForEach(module->plugins, pf_modules_proxy_ArrayList_ForEachFkt, type, pdata,
246 custom);
247}
248
249WINPR_ATTR_NODISCARD
250static BOOL pf_modules_ArrayList_ForEachFkt(void* data, size_t index, va_list ap)
251{
252 proxyPlugin* plugin = (proxyPlugin*)data;
253 BOOL result = FALSE;
254
255 WINPR_UNUSED(index);
256
257 PF_FILTER_TYPE type = va_arg(ap, PF_FILTER_TYPE);
258 proxyData* pdata = va_arg(ap, proxyData*);
259 void* param = va_arg(ap, void*);
260
261 WLog_VRB(TAG, "running filter: %s", plugin->name);
262
263 switch (type)
264 {
265 case FILTER_TYPE_KEYBOARD:
266 result = IFCALLRESULT(TRUE, plugin->KeyboardEvent, plugin, pdata, param);
267 break;
268
269 case FILTER_TYPE_UNICODE:
270 result = IFCALLRESULT(TRUE, plugin->UnicodeEvent, plugin, pdata, param);
271 break;
272
273 case FILTER_TYPE_MOUSE:
274 result = IFCALLRESULT(TRUE, plugin->MouseEvent, plugin, pdata, param);
275 break;
276
277 case FILTER_TYPE_MOUSE_EX:
278 result = IFCALLRESULT(TRUE, plugin->MouseExEvent, plugin, pdata, param);
279 break;
280
281 case FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_DATA:
282 result = IFCALLRESULT(TRUE, plugin->ClientChannelData, plugin, pdata, param);
283 break;
284
285 case FILTER_TYPE_SERVER_PASSTHROUGH_CHANNEL_DATA:
286 result = IFCALLRESULT(TRUE, plugin->ServerChannelData, plugin, pdata, param);
287 break;
288
289 case FILTER_TYPE_CLIENT_PASSTHROUGH_CHANNEL_CREATE:
290 result = IFCALLRESULT(TRUE, plugin->ChannelCreate, plugin, pdata, param);
291 break;
292
293 case FILTER_TYPE_CLIENT_PASSTHROUGH_DYN_CHANNEL_CREATE:
294 result = IFCALLRESULT(TRUE, plugin->DynamicChannelCreate, plugin, pdata, param);
295 break;
296
297 case FILTER_TYPE_SERVER_FETCH_TARGET_ADDR:
298 result = IFCALLRESULT(TRUE, plugin->ServerFetchTargetAddr, plugin, pdata, param);
299 break;
300
301 case FILTER_TYPE_SERVER_PEER_LOGON:
302 result = IFCALLRESULT(TRUE, plugin->ServerPeerLogon, plugin, pdata, param);
303 break;
304
305 case FILTER_TYPE_INTERCEPT_CHANNEL:
306 result = IFCALLRESULT(TRUE, plugin->DynChannelIntercept, plugin, pdata, param);
307 break;
308
309 case FILTER_TYPE_DYN_INTERCEPT_LIST:
310 result = IFCALLRESULT(TRUE, plugin->DynChannelToIntercept, plugin, pdata, param);
311 break;
312
313 case FILTER_TYPE_STATIC_INTERCEPT_LIST:
314 result = IFCALLRESULT(TRUE, plugin->StaticChannelToIntercept, plugin, pdata, param);
315 break;
316
317 case FILTER_LAST:
318 default:
319 WLog_ERR(TAG, "invalid filter called");
320 }
321
322 if (!result)
323 {
324 /* current filter return FALSE, no need to run other filters. */
325 WLog_DBG(TAG, "plugin %s, filter type [%s] returned FALSE", plugin->name,
326 pf_modules_get_filter_type_string(type));
327 }
328 return result;
329}
330
331/*
332 * runs all filters of type `type`.
333 *
334 * @type: filter type to run.
335 * @server: pointer of server's rdpContext struct of the current session.
336 */
337BOOL pf_modules_run_filter(proxyModule* module, PF_FILTER_TYPE type, proxyData* pdata, void* param)
338{
339 WINPR_ASSERT(module);
340 WINPR_ASSERT(module->plugins);
341
342 return ArrayList_ForEach(module->plugins, pf_modules_ArrayList_ForEachFkt, type, pdata, param);
343}
344
345/*
346 * stores per-session data needed by a plugin.
347 *
348 * @context: current session server's rdpContext instance.
349 * @info: pointer to per-session data.
350 */
351WINPR_ATTR_NODISCARD
352static BOOL pf_modules_set_plugin_data(WINPR_ATTR_UNUSED proxyPluginsManager* mgr,
353 const char* plugin_name, proxyData* pdata, void* data)
354{
355 union
356 {
357 const char* ccp;
358 char* cp;
359 } ccharconv;
360
361 WINPR_ASSERT(plugin_name);
362
363 ccharconv.ccp = plugin_name;
364 if (data == nullptr) /* no need to store anything */
365 return FALSE;
366
367 if (!HashTable_Insert(pdata->modules_info, ccharconv.cp, data))
368 {
369 WLog_ERR(TAG, "HashTable_Insert failed!");
370 return FALSE;
371 }
372
373 return TRUE;
374}
375
376/*
377 * returns per-session data needed a plugin.
378 *
379 * @context: current session server's rdpContext instance.
380 * if there's no data related to `plugin_name` in `context` (current session), a nullptr will be
381 * returned.
382 */
383WINPR_ATTR_NODISCARD
384static void* pf_modules_get_plugin_data(WINPR_ATTR_UNUSED proxyPluginsManager* mgr,
385 const char* plugin_name, proxyData* pdata)
386{
387 union
388 {
389 const char* ccp;
390 char* cp;
391 } ccharconv;
392 WINPR_ASSERT(plugin_name);
393 WINPR_ASSERT(pdata);
394 ccharconv.ccp = plugin_name;
395
396 return HashTable_GetItemValue(pdata->modules_info, ccharconv.cp);
397}
398
399static void pf_modules_abort_connect(WINPR_ATTR_UNUSED proxyPluginsManager* mgr, proxyData* pdata)
400{
401 WINPR_ASSERT(pdata);
402 WLog_DBG(TAG, "is called!");
403 proxy_data_abort_connect(pdata);
404}
405
406WINPR_ATTR_NODISCARD
407static BOOL pf_modules_register_ArrayList_ForEachFkt(void* data, size_t index, va_list ap)
408{
409 proxyPlugin* plugin = (proxyPlugin*)data;
410 proxyPlugin* plugin_to_register = va_arg(ap, proxyPlugin*);
411
412 WINPR_UNUSED(index);
413
414 if (strcmp(plugin->name, plugin_to_register->name) == 0)
415 {
416 WLog_ERR(TAG, "can not register plugin '%s', it is already registered!", plugin->name);
417 return FALSE;
418 }
419 return TRUE;
420}
421
422WINPR_ATTR_NODISCARD
423static BOOL pf_modules_register_plugin(proxyPluginsManager* mgr,
424 const proxyPlugin* plugin_to_register)
425{
426 proxyPlugin internal = WINPR_C_ARRAY_INIT;
427 proxyModule* module = (proxyModule*)mgr;
428 WINPR_ASSERT(module);
429
430 if (!plugin_to_register)
431 return FALSE;
432
433 internal = *plugin_to_register;
434 internal.mgr = mgr;
435
436 /* make sure there's no other loaded plugin with the same name of `plugin_to_register`. */
437 if (!ArrayList_ForEach(module->plugins, pf_modules_register_ArrayList_ForEachFkt, &internal))
438 return FALSE;
439
440 if (!ArrayList_Append(module->plugins, &internal))
441 {
442 WLog_ERR(TAG, "failed adding plugin to list: %s", plugin_to_register->name);
443 return FALSE;
444 }
445 WLog_INFO(TAG, "Successfully registered proxy plugin '%s'", plugin_to_register->name);
446
447 return TRUE;
448}
449
450WINPR_ATTR_NODISCARD
451static BOOL pf_modules_load_ArrayList_ForEachFkt(void* data, size_t index, va_list ap)
452{
453 proxyPlugin* plugin = (proxyPlugin*)data;
454 const char* plugin_name = va_arg(ap, const char*);
455 BOOL* res = va_arg(ap, BOOL*);
456
457 WINPR_UNUSED(index);
458 WINPR_UNUSED(ap);
459 WINPR_ASSERT(res);
460
461 if (strcmp(plugin->name, plugin_name) == 0)
462 *res = TRUE;
463 return TRUE;
464}
465
466BOOL pf_modules_is_plugin_loaded(proxyModule* module, const char* plugin_name)
467{
468 BOOL rc = FALSE;
469 WINPR_ASSERT(module);
470 if (ArrayList_Count(module->plugins) < 1)
471 return FALSE;
472 if (!ArrayList_ForEach(module->plugins, pf_modules_load_ArrayList_ForEachFkt, plugin_name, &rc))
473 return FALSE;
474 return rc;
475}
476
477WINPR_ATTR_NODISCARD
478static BOOL pf_modules_print_ArrayList_ForEachFkt(void* data, size_t index, va_list ap)
479{
480 proxyPlugin* plugin = (proxyPlugin*)data;
481
482 WINPR_UNUSED(index);
483 WINPR_UNUSED(ap);
484
485 WLog_INFO(TAG, "\tName: %s", plugin->name);
486 WLog_INFO(TAG, "\tDescription: %s", plugin->description);
487 return TRUE;
488}
489
490BOOL pf_modules_list_loaded_plugins(proxyModule* module)
491{
492 size_t count = 0;
493
494 WINPR_ASSERT(module);
495 WINPR_ASSERT(module->plugins);
496
497 count = ArrayList_Count(module->plugins);
498
499 if (count > 0)
500 WLog_INFO(TAG, "Loaded plugins:");
501
502 return ArrayList_ForEach(module->plugins, pf_modules_print_ArrayList_ForEachFkt);
503}
504
505WINPR_ATTR_NODISCARD
506static BOOL pf_modules_load_static_module(const char* module_name, proxyModule* module,
507 void* userdata)
508{
509 WINPR_ASSERT(module);
510
511 HANDLE handle = GetModuleHandleA(nullptr);
512
513 if (handle == nullptr)
514 {
515 WLog_DBG(TAG, "failed loading static library: %s", module_name);
516 return FALSE;
517 }
518
519 char name[256] = WINPR_C_ARRAY_INIT;
520 (void)_snprintf(name, sizeof(name), "%s_%s", module_name, MODULE_ENTRY_POINT);
521 for (size_t x = 0; x < strnlen(name, sizeof(name)); x++)
522 {
523 if (name[x] == '-')
524 name[x] = '_';
525 }
526
527 proxyModuleEntryPoint pEntryPoint = GetProcAddressAs(handle, name, proxyModuleEntryPoint);
528 if (!pEntryPoint)
529 {
530 WLog_DBG(TAG, "GetProcAddress failed for static %s (module %s)", name, module_name);
531 goto error;
532 }
533 if (!ArrayList_Append(module->handles, handle))
534 {
535 WLog_ERR(TAG, "ArrayList_Append failed!");
536 goto error;
537 }
538 return pf_modules_add(module, pEntryPoint, userdata);
539
540error:
541 FreeLibrary(handle);
542 return FALSE;
543}
544
545WINPR_ATTR_NODISCARD
546static BOOL pf_modules_load_dynamic_module(const char* module_path, proxyModule* module,
547 void* userdata)
548{
549 if (!winpr_PathFileExists(module_path))
550 {
551 WLog_DBG(TAG, "failed loading external library: file '%s' does not exist", module_path);
552 return FALSE;
553 }
554
555 HANDLE handle = LoadLibraryX(module_path);
556
557 if (handle == nullptr)
558 {
559 WLog_DBG(TAG, "failed loading external library: %s", module_path);
560 return FALSE;
561 }
562
563 proxyModuleEntryPoint pEntryPoint =
564 GetProcAddressAs(handle, MODULE_ENTRY_POINT, proxyModuleEntryPoint);
565 if (!pEntryPoint)
566 {
567 WLog_DBG(TAG, "GetProcAddress failed while loading %s", module_path);
568 goto error;
569 }
570 if (!ArrayList_Append(module->handles, handle))
571 {
572 WLog_ERR(TAG, "ArrayList_Append failed!");
573 goto error;
574 }
575 return pf_modules_add(module, pEntryPoint, userdata);
576
577error:
578 FreeLibrary(handle);
579 return FALSE;
580}
581
582WINPR_ATTR_NODISCARD
583static BOOL pf_modules_try_load_dynamic_module(const char* module_path, proxyModule* module,
584 void* userdata, size_t count, const char* names[])
585{
586 for (size_t x = 0; x < count; x++)
587 {
588 const char* name = names[x];
589
590 char* fullpath = GetCombinedPath(module_path, name);
591 if (!fullpath)
592 continue;
593
594 const BOOL rc = pf_modules_load_dynamic_module(fullpath, module, userdata);
595 free(fullpath);
596 if (rc)
597 return TRUE;
598 }
599 return FALSE;
600}
601
602WINPR_ATTR_NODISCARD
603static BOOL pf_modules_load_module(const char* module_path, const char* module_name,
604 proxyModule* module, void* userdata)
605{
606 WINPR_ASSERT(module);
607
608 if (pf_modules_load_static_module(module_name, module, userdata))
609 return TRUE;
610
611 char names[5][MAX_PATH] = WINPR_C_ARRAY_INIT;
612 (void)_snprintf(names[0], sizeof(names[0]), "proxy-%s-plugin%s", module_name,
613 FREERDP_SHARED_LIBRARY_SUFFIX);
614 (void)_snprintf(names[1], sizeof(names[1]), "%sproxy-%s-plugin%s",
615 FREERDP_SHARED_LIBRARY_PREFIX, module_name, FREERDP_SHARED_LIBRARY_SUFFIX);
616 (void)_snprintf(names[2], sizeof(names[2]), "%sproxy-%s-plugin%s.%d",
617 FREERDP_SHARED_LIBRARY_PREFIX, module_name, FREERDP_SHARED_LIBRARY_SUFFIX,
618 FREERDP_VERSION_MAJOR);
619 (void)_snprintf(names[3], sizeof(names[3]), "%sproxy-%s-plugin%d%s",
620 FREERDP_SHARED_LIBRARY_PREFIX, module_name, FREERDP_VERSION_MAJOR,
621 FREERDP_SHARED_LIBRARY_SUFFIX);
622 (void)_snprintf(names[4], sizeof(names[4]), "%sproxy-%s-plugin%d%s.%d",
623 FREERDP_SHARED_LIBRARY_PREFIX, module_name, FREERDP_VERSION_MAJOR,
624 FREERDP_SHARED_LIBRARY_SUFFIX, FREERDP_VERSION_MAJOR);
625
626 const char* cnames[5] = { names[0], names[1], names[2], names[3], names[4] };
627 return pf_modules_try_load_dynamic_module(module_path, module, userdata, ARRAYSIZE(cnames),
628 cnames);
629}
630
631static void free_handle(void* obj)
632{
633 HANDLE handle = (HANDLE)obj;
634 if (handle)
635 FreeLibrary(handle);
636}
637
638static void free_plugin(void* obj)
639{
640 proxyPlugin* plugin = (proxyPlugin*)obj;
641 WINPR_ASSERT(plugin);
642
643 if (!IFCALLRESULT(TRUE, plugin->PluginUnload, plugin))
644 WLog_WARN(TAG, "PluginUnload failed for plugin '%s'", plugin->name);
645
646 free(plugin);
647}
648
649WINPR_ATTR_MALLOC(free_plugin, 1)
650WINPR_ATTR_NODISCARD
651static void* new_plugin(const void* obj)
652{
653 const proxyPlugin* src = obj;
654 proxyPlugin* proxy = calloc(1, sizeof(proxyPlugin));
655 if (!proxy)
656 return nullptr;
657 *proxy = *src;
658 return proxy;
659}
660
661proxyModule* pf_modules_new(const char* root_dir, const char** modules, size_t count)
662{
663 wObject* obj = nullptr;
664 char* path = nullptr;
665 proxyModule* module = calloc(1, sizeof(proxyModule));
666 if (!module)
667 return nullptr;
668
669 module->mgr.RegisterPlugin = pf_modules_register_plugin;
670 module->mgr.SetPluginData = pf_modules_set_plugin_data;
671 module->mgr.GetPluginData = pf_modules_get_plugin_data;
672 module->mgr.AbortConnect = pf_modules_abort_connect;
673 module->plugins = ArrayList_New(FALSE);
674
675 if (module->plugins == nullptr)
676 {
677 WLog_ERR(TAG, "ArrayList_New failed!");
678 goto error;
679 }
680 obj = ArrayList_Object(module->plugins);
681 WINPR_ASSERT(obj);
682
683 obj->fnObjectFree = free_plugin;
684 obj->fnObjectNew = new_plugin;
685
686 module->handles = ArrayList_New(FALSE);
687 if (module->handles == nullptr)
688 {
689
690 WLog_ERR(TAG, "ArrayList_New failed!");
691 goto error;
692 }
693 ArrayList_Object(module->handles)->fnObjectFree = free_handle;
694
695 if (count > 0)
696 {
697 WINPR_ASSERT(root_dir);
698 if (!winpr_PathFileExists(root_dir))
699 path = GetCombinedPath(FREERDP_INSTALL_PREFIX, root_dir);
700 else
701 path = _strdup(root_dir);
702
703 if (!winpr_PathFileExists(path))
704 {
705 if (!winpr_PathMakePath(path, nullptr))
706 {
707 WLog_ERR(TAG, "error occurred while creating modules directory: %s", root_dir);
708 }
709 }
710
711 if (winpr_PathFileExists(path))
712 WLog_DBG(TAG, "modules root directory: %s", path);
713
714 for (size_t i = 0; i < count; i++)
715 {
716 const char* module_name = modules[i];
717 if (!pf_modules_load_module(path, module_name, module, nullptr))
718 WLog_WARN(TAG, "Failed to load proxy module '%s'", module_name);
719 else
720 WLog_INFO(TAG, "Successfully loaded proxy module '%s'", module_name);
721 }
722 }
723
724 free(path);
725 return module;
726
727error:
728 free(path);
729 pf_modules_free(module);
730 return nullptr;
731}
732
733void pf_modules_free(proxyModule* module)
734{
735 if (!module)
736 return;
737
738 ArrayList_Free(module->plugins);
739 ArrayList_Free(module->handles);
740 free(module);
741}
742
743BOOL pf_modules_add(proxyModule* module, proxyModuleEntryPoint ep, void* userdata)
744{
745 WINPR_ASSERT(module);
746 WINPR_ASSERT(ep);
747
748 return ep(&module->mgr, userdata);
749}
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectNew
WINPR_ATTR_NODISCARD OBJECT_NEW_FN fnObjectNew
Definition collections.h:54