Line data Source code
1 : /*************************************************************
2 : * gnc-module.c -- loadable plugin/module system for gnucash
3 : * Copyright 2001 Linux Developers Group, Inc.
4 : *************************************************************/
5 : /********************************************************************\
6 : * This program is free software; you can redistribute it and/or *
7 : * modify it under the terms of the GNU General Public License as *
8 : * published by the Free Software Foundation; either version 2 of *
9 : * the License, or (at your option) any later version. *
10 : * *
11 : * This program is distributed in the hope that it will be useful, *
12 : * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 : * GNU General Public License for more details. *
15 : * *
16 : * You should have received a copy of the GNU General Public License*
17 : * along with this program; if not, contact: *
18 : * *
19 : * Free Software Foundation Voice: +1-617-542-5942 *
20 : * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
21 : * Boston, MA 02110-1301, USA gnu@gnu.org *
22 : * *
23 : \********************************************************************/
24 :
25 :
26 : #include <config.h>
27 :
28 : #include <stdio.h>
29 : #include <stdlib.h>
30 : #include <string.h>
31 : #include <gmodule.h>
32 : #include <sys/types.h>
33 : #ifdef HAVE_DIRENT_H
34 : # include <dirent.h>
35 : #endif
36 :
37 : #include "gnc-module.h"
38 :
39 : static GHashTable * loaded_modules = NULL;
40 : static GList * module_info = NULL;
41 :
42 : typedef struct
43 : {
44 : char * module_path;
45 : char * module_description;
46 : char * module_filepath;
47 : int module_interface;
48 : int module_age;
49 : int module_revision;
50 : } GNCModuleInfo;
51 :
52 : typedef struct
53 : {
54 : GModule * gmodule;
55 : gchar * filename;
56 : int load_count;
57 : GNCModuleInfo * info;
58 : int (* init_func)(int refcount);
59 : } GNCLoadedModule;
60 :
61 : static GNCModuleInfo * gnc_module_get_info(const char * lib_path);
62 :
63 : /*************************************************************
64 : * gnc_module_system_search_dirs
65 : * return a list of dirs to look in for gnc_module libraries
66 : *************************************************************/
67 :
68 : static GList *
69 6 : gnc_module_system_search_dirs(void)
70 : {
71 6 : const char *spath = g_getenv("GNC_MODULE_PATH");
72 6 : GList * list = NULL;
73 6 : GString * token = g_string_new(NULL);
74 6 : int escchar = 0;
75 : const char *cpos;
76 :
77 6 : if (!spath)
78 : {
79 2 : spath = DEFAULT_MODULE_PATH;
80 : }
81 :
82 297 : for (cpos = spath; *cpos; cpos++)
83 : {
84 291 : switch (*cpos)
85 : {
86 : #ifndef G_OS_WIN32
87 : /* On windows, with '\' as the directory separator character,
88 : this additional de-quoting will make every path processing
89 : fail miserably. Anyway this should probably be thrown out
90 : altogether, because this additional level of de-quoting
91 : (after shell quoting) is completely unexpected and
92 : uncommon. */
93 0 : case '\\':
94 0 : if (!escchar)
95 : {
96 0 : escchar = TRUE;
97 : }
98 : else
99 : {
100 0 : g_string_append_c(token, *cpos);
101 0 : escchar = FALSE;
102 : }
103 0 : break;
104 : #endif
105 :
106 : /* This is ':' on UNIX machines and ';' under Windows. */
107 0 : case G_SEARCHPATH_SEPARATOR:
108 0 : if (!escchar)
109 : {
110 0 : char *token_str = g_string_free (token, FALSE);
111 0 : list = g_list_append (list, token_str);
112 0 : token = g_string_new(NULL);
113 : }
114 : else
115 : {
116 0 : g_string_append_c(token, *cpos);
117 0 : escchar = FALSE;
118 : }
119 0 : break;
120 :
121 291 : default:
122 291 : g_string_append_c(token, *cpos);
123 291 : escchar = FALSE;
124 291 : break;
125 : }
126 : }
127 6 : if (token->len)
128 : {
129 6 : char *token_str = g_string_free (token, FALSE);
130 6 : list = g_list_append(list, token_str);
131 : }
132 : else
133 : {
134 0 : g_string_free(token, TRUE);
135 : }
136 6 : return list;
137 : }
138 :
139 : /*************************************************************
140 : * gnc_module_system_init
141 : * initialize the module system
142 : *************************************************************/
143 : void
144 6 : gnc_module_system_init(void)
145 : {
146 6 : if (loaded_modules)
147 0 : return;
148 :
149 6 : loaded_modules = g_hash_table_new(g_direct_hash, g_direct_equal);
150 :
151 : /* now crawl the GNC_MODULE_PATH to find likely libraries */
152 6 : gnc_module_system_refresh();
153 : }
154 :
155 : static inline gboolean
156 13 : exclude_module (const char* module)
157 : {
158 : /* These modules were converted to shared libraries and removed
159 : * from GnuCash 4. Simply dlopening them will introduce duplicate
160 : * symbols and cause unwanted initializations that may lead to a
161 : * crash. See https://bugs.gnucash.org/show_bug.cgi?id=798229.
162 : */
163 : static const char* excluded_modules[] =
164 : {
165 : "libgncmod-app-utils",
166 : "libgncmod-bi-import",
167 : "libgncmod-csv-export",
168 : "libgncmod-csv-import",
169 : "libgncmod-customer-import",
170 : "libgncmod-engine",
171 : "libgncmod-generic-import",
172 : "libgncmod-gnome-search",
173 : "libgncmod-gnome-utils",
174 : "libgncmod-html",
175 : "libgncmod-ledger-core",
176 : "libgncmod-locale-reports-us",
177 : "libgncmod-log-replay",
178 : "libgncmod-qif-import",
179 : "libgncmod-register-core",
180 : "libgncmod-register-gnome",
181 : "libgncmod-report-gnome",
182 : "libgncmod-report-system",
183 : "libgncmod-stylesheets",
184 : "libgncmod-tax-us"
185 : };
186 : static const unsigned len = G_N_ELEMENTS (excluded_modules);
187 13 : unsigned namelen = strchr(module, '.') ?
188 0 : strchr(module, '.') - module : strlen (module);
189 273 : for (unsigned i = 0; i < len; ++i)
190 260 : if (strncmp(excluded_modules[i], module, MIN(namelen, strlen(excluded_modules[i]))) == 0)
191 0 : return TRUE;
192 13 : return FALSE;
193 : }
194 :
195 : /*************************************************************
196 : * gnc_module_system_refresh
197 : * build the database of modules by looking through the
198 : * GNC_MODULE_PATH
199 : *************************************************************/
200 :
201 : void
202 6 : gnc_module_system_refresh(void)
203 : {
204 : GList * search_dirs;
205 : GList * current;
206 :
207 6 : if (!loaded_modules)
208 : {
209 0 : gnc_module_system_init();
210 : }
211 :
212 : /* get the GNC_MODULE_PATH and split it into directories */
213 6 : search_dirs = gnc_module_system_search_dirs();
214 :
215 : /* look in each search directory */
216 12 : for (current = search_dirs; current; current = current->next)
217 : {
218 6 : GDir *d = g_dir_open(current->data, 0, NULL);
219 6 : const gchar *dent = NULL;
220 6 : char * fullpath = NULL;
221 : GNCModuleInfo * info;
222 :
223 6 : if (!d) continue;
224 :
225 26 : while ((dent = g_dir_read_name(d)) != NULL)
226 : {
227 : /* is the file a loadable module? */
228 :
229 : /* Gotcha: On MacOS, G_MODULE_SUFFIX is defined as "so",
230 : * but if we do not build clean libtool modules with
231 : * "-module", we get dynamic libraries ending in .dylib
232 : * On Windows, all modules will move to bin/, so they will
233 : * be mixed with other libraries, such as gtk+. Adding a
234 : * prefix "libgncmod" filter will prevent the module loader
235 : * from loading other libraries. The filter should work on
236 : * other platforms.
237 : */
238 22 : if ((g_str_has_suffix(dent, "." G_MODULE_SUFFIX)
239 3 : || g_str_has_suffix(dent, ".dylib"))
240 19 : && g_str_has_prefix(dent, GNC_MODULE_PREFIX)
241 13 : && !exclude_module(dent))
242 : {
243 : /* get the full path name, then dlopen the library and see
244 : * if it has the appropriate symbols to be a gnc_module */
245 13 : fullpath = g_build_filename((const gchar *)(current->data),
246 : dent, (char*)NULL);
247 13 : info = gnc_module_get_info(fullpath);
248 :
249 13 : if (info)
250 : {
251 12 : module_info = g_list_prepend(module_info, info);
252 : }
253 13 : g_free(fullpath);
254 : }
255 : }
256 4 : g_dir_close(d);
257 :
258 : }
259 : /* free the search dir strings */
260 6 : g_list_free_full (search_dirs, g_free);
261 6 : }
262 :
263 :
264 : /*************************************************************
265 : * gnc_module_system_modinfo
266 : * return the list of module information
267 : *************************************************************/
268 :
269 : GList *
270 0 : gnc_module_system_modinfo(void)
271 : {
272 0 : if (!loaded_modules)
273 : {
274 0 : gnc_module_system_init();
275 : }
276 :
277 0 : return module_info;
278 : }
279 :
280 :
281 : /*
282 : * gnc_module_get_symbol
283 : * gets the munged symbol from the file
284 : */
285 : static gboolean
286 92 : gnc_module_get_symbol(GModule* gmodule, const char* symbol, gpointer res)
287 : {
288 : gchar** strs;
289 : gchar* munged_symbol;
290 : gchar *basename;
291 : gboolean ret;
292 :
293 92 : g_return_val_if_fail(gmodule, FALSE);
294 92 : g_return_val_if_fail(symbol, FALSE);
295 :
296 : /* Separate the file from its extension */
297 : /* Note: This currently does not work with versioned libtool dlls,
298 : * as they are named like libgncmodbaz-0.dll */
299 92 : basename = g_path_get_basename(g_module_name(gmodule));
300 92 : strs = g_strsplit(basename, ".", 2);
301 92 : g_free(basename);
302 :
303 : /* Translate any dashes to underscores */
304 92 : g_strdelimit(strs[0], "-", '_');
305 :
306 : /* Create the symbol <filename>_<symbol> and retrieve that symbol */
307 92 : munged_symbol = g_strdup_printf("%s_%s", strs[0], symbol);
308 92 : ret = g_module_symbol(gmodule, munged_symbol, res);
309 :
310 : /* printf("(%d) Looking for symbol %s\n", ret, munged_symbol); */
311 :
312 : /* Free everything */
313 92 : g_strfreev(strs);
314 92 : g_free(munged_symbol);
315 92 : return ret;
316 : }
317 :
318 : /*************************************************************
319 : * gnc_module_get_info
320 : * check a proposed gnc_module by looking for specific symbols in it;
321 : * if it's a gnc_module, return a struct describing it.
322 : *************************************************************/
323 :
324 : static GNCModuleInfo *
325 13 : gnc_module_get_info(const char * fullpath)
326 : {
327 : GModule *gmodule;
328 : gpointer modsysver;
329 13 : GNCModuleInfo *info = NULL;
330 : gpointer initfunc, pathfunc, descripfunc, iface, revision, age;
331 : gchar * (* f_path)(void);
332 : gchar * (* f_descrip)(void);
333 :
334 : /* g_debug("(init) dlopening '%s'\n", fullpath); */
335 13 : gmodule = g_module_open(fullpath, G_MODULE_BIND_LAZY);
336 13 : if (gmodule == NULL)
337 : {
338 0 : g_debug("Failed to dlopen() '%s': %s\n", fullpath, g_module_error());
339 0 : return NULL;
340 : }
341 :
342 : /* the modsysver tells us what the expected symbols and their
343 : * types are */
344 13 : if (!gnc_module_get_symbol(gmodule, "gnc_module_system_interface", &modsysver))
345 : {
346 : /* g_debug("Module '%s' does not contain 'gnc_module_system_interface'\n", */
347 : /* fullpath); */
348 0 : goto get_info_close;
349 : }
350 :
351 13 : if (*(int *)modsysver != 0)
352 : {
353 1 : g_warning("Module '%s' requires newer module system\n", fullpath);
354 1 : goto get_info_close;
355 : }
356 :
357 24 : if (!gnc_module_get_symbol(gmodule, "gnc_module_init", &initfunc) ||
358 24 : !gnc_module_get_symbol(gmodule, "gnc_module_path", &pathfunc) ||
359 24 : !gnc_module_get_symbol(gmodule, "gnc_module_description", &descripfunc) ||
360 24 : !gnc_module_get_symbol(gmodule, "gnc_module_current", &iface) ||
361 24 : !gnc_module_get_symbol(gmodule, "gnc_module_revision", &revision) ||
362 12 : !gnc_module_get_symbol(gmodule, "gnc_module_age", &age))
363 : {
364 0 : g_warning("Module '%s' does not match module signature\n", fullpath);
365 0 : goto get_info_close;
366 : }
367 :
368 : /* we have found a gnc_module. */
369 12 : info = g_new0(GNCModuleInfo, 1);
370 12 : f_path = pathfunc;
371 12 : f_descrip = descripfunc;
372 12 : info->module_path = f_path();
373 12 : info->module_description = f_descrip();
374 12 : info->module_filepath = g_strdup(fullpath);
375 12 : info->module_interface = *(int *)iface;
376 12 : info->module_age = *(int *)age;
377 12 : info->module_revision = *(int *)revision;
378 :
379 12 : g_module_make_resident(gmodule);
380 13 : get_info_close:
381 : /* g_debug("(init) closing '%s'\n", fullpath); */
382 13 : g_module_close(gmodule);
383 :
384 13 : return info;
385 : }
386 :
387 :
388 : /*************************************************************
389 : * gnc_module_locate
390 : * find the best matching module for the name, interface pair
391 : *************************************************************/
392 :
393 : static GNCModuleInfo *
394 14 : gnc_module_locate(const gchar * module_name, int iface)
395 : {
396 14 : GNCModuleInfo * best = NULL;
397 14 : GNCModuleInfo * current = NULL;
398 : GList * lptr;
399 :
400 14 : if (!loaded_modules)
401 : {
402 0 : gnc_module_system_init();
403 : }
404 :
405 62 : for (lptr = module_info; lptr; lptr = lptr->next)
406 : {
407 48 : current = lptr->data;
408 48 : if (!strcmp(module_name, current->module_path) &&
409 12 : (iface >= (current->module_interface - current->module_age)) &&
410 12 : (iface <= current->module_interface))
411 : {
412 10 : if (best)
413 : {
414 0 : if ((current->module_interface > best->module_interface) ||
415 0 : ((current->module_interface == best->module_interface) &&
416 0 : (current->module_age > best->module_age)) ||
417 0 : ((current->module_interface == best->module_interface) &&
418 0 : (current->module_age == best->module_age) &&
419 0 : (current->module_revision > best->module_revision)))
420 : {
421 0 : best = current;
422 : }
423 : }
424 : else
425 : {
426 10 : best = current;
427 : }
428 : }
429 : }
430 14 : return best;
431 : }
432 :
433 : static void
434 1 : list_loaded (gpointer k, gpointer v, gpointer data)
435 : {
436 1 : GList ** l = data;
437 1 : *l = g_list_prepend(*l, v);
438 1 : }
439 :
440 : static GNCLoadedModule *
441 7 : gnc_module_check_loaded(const char * module_name, gint iface)
442 : {
443 7 : GNCModuleInfo * modinfo = gnc_module_locate(module_name, iface);
444 7 : GList * modules = NULL;
445 7 : GList * p = NULL;
446 7 : GNCLoadedModule * rv = NULL;
447 :
448 7 : if (modinfo == NULL)
449 : {
450 2 : return NULL;
451 : }
452 :
453 5 : if (!loaded_modules)
454 : {
455 0 : gnc_module_system_init();
456 : }
457 :
458 : /* turn the loaded-modules table into a list */
459 5 : g_hash_table_foreach(loaded_modules, list_loaded, &modules);
460 :
461 : /* walk the list to see if the file we want is already open */
462 6 : for (p = modules; p; p = p->next)
463 : {
464 1 : GNCLoadedModule * lm = p->data;
465 1 : if (!strcmp(lm->filename, modinfo->module_filepath))
466 : {
467 0 : rv = lm;
468 0 : break;
469 : }
470 : }
471 5 : g_list_free(modules);
472 5 : return rv;
473 : }
474 :
475 :
476 : /*************************************************************
477 : * gnc_module_load
478 : * Ensure that the module named by "module_name" is loaded.
479 : *************************************************************/
480 :
481 : static GNCModule
482 7 : gnc_module_load_common(const char * module_name, gint iface, gboolean optional)
483 : {
484 :
485 : GNCLoadedModule * info;
486 : GModule * gmodule;
487 : GNCModuleInfo * modinfo;
488 :
489 7 : g_debug ("module_name: %s", module_name);
490 :
491 7 : if (!loaded_modules)
492 : {
493 0 : gnc_module_system_init();
494 : }
495 :
496 7 : info = gnc_module_check_loaded(module_name, iface);
497 :
498 : /* if the module's already loaded, just increment its use count.
499 : * otherwise, load it and check for the initializer
500 : * "gnc_module_init". if we find that, assume it's a gnucash module
501 : * and run the function. */
502 :
503 7 : if (info)
504 : {
505 : /* module already loaded ... call the init thunk */
506 0 : if (info->init_func)
507 : {
508 0 : if (info->init_func(info->load_count))
509 : {
510 0 : info->load_count++;
511 0 : g_debug ("module %s already loaded", module_name);
512 0 : return info;
513 : }
514 : else
515 : {
516 0 : g_warning ("module init failed: %s", module_name);
517 0 : return NULL;
518 : }
519 : }
520 : else
521 : {
522 0 : g_warning ("module has no init func: %s", module_name);
523 0 : return NULL;
524 : }
525 : /* NOTREACHED */
526 : g_error("internal error");
527 : return NULL;
528 : }
529 :
530 7 : modinfo = gnc_module_locate(module_name, iface);
531 7 : if (!modinfo)
532 : {
533 2 : if (optional)
534 : {
535 0 : g_message ("Could not locate optional module %s interface v.%d",
536 : module_name, iface);
537 : }
538 : else
539 : {
540 2 : g_warning ("Could not locate module %s interface v.%d",
541 : module_name, iface);
542 : }
543 2 : return NULL;
544 : }
545 :
546 : /* if (modinfo) */
547 : /* g_debug("(init) loading '%s' from '%s'\n", module_name, */
548 : /* modinfo->module_filepath); */
549 :
550 5 : if ((gmodule = g_module_open(modinfo->module_filepath, 0)) != NULL)
551 : {
552 : gpointer initfunc;
553 :
554 5 : if (gnc_module_get_symbol(gmodule, "gnc_module_init", &initfunc))
555 : {
556 : /* stick it in the hash table */
557 5 : info = g_new0(GNCLoadedModule, 1);
558 5 : info->gmodule = gmodule;
559 5 : info->filename = g_strdup(modinfo->module_filepath);
560 5 : info->load_count = 1;
561 5 : info->init_func = initfunc;
562 5 : g_hash_table_insert(loaded_modules, info, info);
563 :
564 : /* now call its init function. this should load any dependent
565 : * modules, too. If it doesn't return TRUE unload the module. */
566 5 : if (!info->init_func(0))
567 : {
568 : /* init failed. unload the module. */
569 1 : g_warning ("Initialization failed for module %s", module_name);
570 1 : g_hash_table_remove(loaded_modules, info);
571 1 : g_free(info->filename);
572 1 : g_free(info);
573 : /* g_module_close(module); */
574 1 : return NULL;
575 : }
576 :
577 4 : return info;
578 : }
579 : else
580 : {
581 0 : g_warning ("Module %s (%s) is not a gnc-module.\n", module_name,
582 : modinfo->module_filepath);
583 : //lt_dlclose(handle);
584 : }
585 0 : return info;
586 : }
587 :
588 0 : g_warning ("Failed to open module %s: %s\n", module_name, g_module_error());
589 :
590 0 : return NULL;
591 : }
592 :
593 :
594 : GNCModule
595 7 : gnc_module_load(const char * module_name, gint iface)
596 : {
597 7 : return gnc_module_load_common(module_name, iface, FALSE);
598 : }
599 :
600 : GNCModule
601 0 : gnc_module_load_optional(const char * module_name, gint iface)
602 : {
603 0 : return gnc_module_load_common(module_name, iface, TRUE);
604 : }
605 :
606 : /*************************************************************
607 : * gnc_module_unload
608 : * unload a module (only actually unload it if the use count goes to 0)
609 : *************************************************************/
610 :
611 : int
612 2 : gnc_module_unload(GNCModule module)
613 : {
614 : GNCLoadedModule * info;
615 :
616 2 : if (!loaded_modules)
617 : {
618 0 : gnc_module_system_init();
619 : }
620 :
621 2 : if ((info = g_hash_table_lookup(loaded_modules, module)) != NULL)
622 : {
623 : gpointer unload_thunk;
624 2 : int unload_val = TRUE;
625 :
626 2 : info->load_count--;
627 2 : if (gnc_module_get_symbol(info->gmodule, "gnc_module_end", &unload_thunk))
628 : {
629 0 : int (* thunk)(int) = unload_thunk;
630 0 : unload_val = thunk(info->load_count);
631 : }
632 :
633 : /* actually unload the module if necessary */
634 2 : if (info->load_count == 0)
635 : {
636 : /* now close the module and free the struct */
637 : /* g_debug("(unload) closing %s\n", info->filename); */
638 : /* g_module_close(info->gmodule); */
639 2 : g_hash_table_remove(loaded_modules, module);
640 2 : g_free(info);
641 : }
642 2 : return unload_val;
643 : }
644 : else
645 : {
646 0 : g_warning ("Failed to unload module %p (it is not loaded)\n", module);
647 0 : return 0;
648 : }
649 : }
650 :
|
