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