ioncore/modules.c

   1 /*
   2  * ion/ioncore/modules.c
   3  *
   4  * Copyright (c) Arnout Engelen 2011
   5  * Copyright (c) Tuomo Valkonen 1999-2009.
   6  *
   7  * See the included file LICENSE for details.
   8  */
   9
  10 #include <string.h>
  11 #include <ctype.h>
  12 #include <dlfcn.h>
  13 #include <unistd.h>
  14
  15 #include <libtu/rb.h>
  16 #include <libextl/readconfig.h>
  17
  18 #include "common.h"
  19 #include "modules.h"
  20 #include "../version.h"
  21
  22
  23 #ifndef CF_PRELOAD_MODULES
  24
  25
  26 /*{{{ Module list */
  27
  28
  29 typedef void *dlhandle;
  30
  31
  32 static Rb_node modules=NULL;
  33
  34
  35 static dlhandle get_handle(const char *name)
  36 {
  37     int found=0;
  38     Rb_node nd;
  39
  40     nd=rb_find_key_n(modules, name, &found);
  41     if(found)
  42         return nd->v.val;
  43     return NULL;
  44 }
  45
  46
  47 static const char *get_name(dlhandle handle)
  48 {
  49     Rb_node nd;
  50
  51     rb_traverse(nd, modules){
  52         if(nd->v.val==handle)
  53             return (const char *)(nd->k.key);
  54     }
  55     return NULL;
  56 }
  57
  58
  59 static Rb_node add_module(char *name, dlhandle handle)
  60 {
  61     return rb_insert(modules, name, handle);
  62 }
  63
  64
  65 /*}}}*/
  66
  67
  68 /*{{{ Module symbol access */
  69
  70
  71 static void *get_module_symbol(dlhandle handle,
  72                                const char *modulename,
  73                                const char *name)
  74 {
  75     char *p;
  76     void *ret;
  77
  78     p=scat(modulename, name);
  79
  80     if(p==NULL)
  81         return NULL;
  82
  83     ret=dlsym(handle, p);
  84
  85     free(p);
  86
  87     return ret;
  88 }
  89
  90 static void (*get_module_fptr(dlhandle handle,
  91                               const char *modulename,
  92                               const char *name))(void **)
  93 {
  94     /* This is not valid ISO C. However, it is 'tried and tested'. The
  95      * workaround originally recommended[1] is not alias-safe[2]. The approach
  96      * we chose, while not valid ISO C, *is* valid under POSIX 2008[3]. Newer
  97      * versions of GCC should not warn about it anymore[4].
  98      *
  99      * [1] http://pubs.opengroup.org/onlinepubs/009695399/functions/dlsym.html#tag_03_112_06)
 100      * [2] http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45289#c1
 101      * [3] http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_12_03
 102      * [4] http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45289#c10
 103      */
 104     return (void (*)(void**)) get_module_symbol(handle, modulename, name);
 105 }
 106
 107 static char *get_version(dlhandle handle, const char *modulename)
 108 {
 109     return (char*)get_module_symbol(handle, modulename,
 110                                               "_ion_api_version");
 111 }
 112
 113 static bool check_has_version(dlhandle handle, const char *modulename)
 114 {
 115     return get_version(handle, modulename) != NULL;
 116 }
 117
 118 static bool check_version(dlhandle handle, const char *modulename)
 119 {
 120     char *versionstr=get_version(handle, modulename);
 121     if(versionstr==NULL)
 122         return FALSE;
 123     return (strcmp(versionstr, NOTION_API_VERSION)==0);
 124 }
 125
 126
 127 static bool call_init(dlhandle handle, const char *modulename)
 128 {
 129     bool (*initfn)(void);
 130
 131     initfn=(bool (*)())get_module_fptr(handle, modulename, "_init");
 132
 133     if(initfn==NULL)
 134         return TRUE;
 135
 136     return initfn();
 137 }
 138
 139
 140 static void call_deinit(dlhandle handle, const char *modulename)
 141 {
 142     void (*deinitfn)(void);
 143
 144     deinitfn=(void (*)())get_module_fptr(handle, modulename, "_deinit");
 145
 146     if(deinitfn!=NULL)
 147         deinitfn();
 148 }
 149
 150
 151 /*}}}*/
 152
 153
 154 /*{{{ Init */
 155
 156
 157 bool ioncore_init_module_support()
 158 {
 159     modules=make_rb();
 160     return (modules!=NULL);
 161 }
 162
 163
 164 static int try_load(const char *file, void *param)
 165 {
 166     dlhandle handle=NULL;
 167     const char *slash, *dot;
 168     char *name;
 169     Rb_node mod;
 170
 171     if(access(file, F_OK)!=0)
 172         return EXTL_TRYCONFIG_NOTFOUND;
 173
 174     slash=strrchr(file, '/');
 175     dot=strrchr(file, '.');
 176
 177     if(slash==NULL)
 178         slash=file;
 179     else
 180         slash++;
 181
 182     if(dot<=slash){
 183         warn(TR("Invalid module name."));
 184         goto err1;
 185     }
 186
 187     name=ALLOC_N(char, dot-slash+1);
 188     if(name==NULL)
 189         goto err1;
 190
 191     strncpy(name, slash, dot-slash);
 192     name[dot-slash]='\0';
 193
 194     if(get_handle(name)){
 195         warn_obj(file, TR("The module is already loaded."));
 196         goto err2;
 197     }
 198
 199     handle=dlopen(file, RTLD_NOW|RTLD_GLOBAL);
 200
 201     if(handle==NULL){
 202         warn_obj(file, "%s", dlerror());
 203         goto err2;
 204     }
 205
 206     if(get_name(handle))
 207         return EXTL_TRYCONFIG_OK;
 208
 209     if(!check_has_version(handle, name)){
 210         warn_obj(file, TR("Module version information for %s not found. "
 211                           "Refusing to use."), name);
 212         goto err3;
 213     }
 214
 215     if(!check_version(handle, name)){
 216         warn_obj(file, TR("Module version mismatch: expected '%s', found '%s'."
 217                           " Refusing to use."),
 218                        NOTION_API_VERSION, get_version(handle, name));
 219         goto err3;
 220     }
 221
 222     mod=add_module(name, handle);
 223
 224     if(mod==NULL)
 225         goto err3;
 226
 227     if(!call_init(handle, name)){
 228         warn_obj(file, TR("Unable to initialise module %s."), name);
 229         rb_delete_node(mod);
 230         goto err3;
 231     }
 232
 233     return EXTL_TRYCONFIG_OK;
 234
 235 err3:
 236     dlclose(handle);
 237 err2:
 238     free(name);
 239 err1:
 240     return EXTL_TRYCONFIG_LOAD_FAILED;
 241 }
 242
 243 static bool do_load_module(const char *modname)
 244 {
 245     int retval;
 246     const char *extension = "so";
 247
 248     retval=extl_try_config(modname, NULL, (ExtlTryConfigFn*)try_load,
 249                            NULL, extension, NULL);
 250
 251     if(retval==EXTL_TRYCONFIG_NOTFOUND)
 252         warn(TR("Unable to find '%s.%s' on search path."), modname, extension);
 253
 254     return (retval==EXTL_TRYCONFIG_OK);
 255 }
 256
 257
 258 /*}}}*/
 259
 260
 261 /*{{{ Deinit */
 262
 263
 264 static void do_unload_module(Rb_node mod)
 265 {
 266     char *name=(char*)mod->k.key;
 267     dlhandle handle=mod->v.val;
 268
 269     call_deinit(handle, name);
 270
 271     dlclose(handle);
 272     free(name);
 273 }
 274
 275
 276 void ioncore_unload_modules()
 277 {
 278     Rb_node mod;
 279
 280     rb_traverse(mod, modules){
 281         do_unload_module(mod);
 282     }
 283 }
 284
 285
 286 /*}}}*/
 287
 288
 289 #else
 290
 291
 292 /*{{{ Static module support */
 293
 294
 295 static bool call_init(WStaticModuleInfo *handle)
 296 {
 297     if(handle->init!=NULL)
 298         return handle->init();
 299     return TRUE;
 300 }
 301
 302
 303 static void call_deinit(WStaticModuleInfo *handle)
 304 {
 305     if(handle->deinit!=NULL)
 306         handle->deinit();
 307 }
 308
 309
 310 extern WStaticModuleInfo ioncore_static_modules[];
 311
 312
 313 static bool do_load_module(const char *name)
 314 {
 315     WStaticModuleInfo *mod;
 316
 317     for(mod=ioncore_static_modules; mod->name!=NULL; mod++){
 318         if(strcmp(mod->name, name)==0)
 319             break;
 320     }
 321
 322     if(mod->name==NULL){
 323         warn_obj(name, TR("Unknown module."));
 324         return FALSE;
 325     }
 326
 327     if(mod->loaded)
 328         return TRUE;
 329
 330     if(!call_init(mod)){
 331         warn_obj(name, TR("Unable to initialise module."));
 332         return FALSE;
 333     }
 334
 335     mod->loaded=TRUE;
 336
 337     return TRUE;
 338 }
 339
 340
 341 void ioncore_unload_modules()
 342 {
 343     WStaticModuleInfo *mod;
 344
 345     for(mod=ioncore_static_modules; mod->name!=NULL; mod++){
 346         if(mod->loaded){
 347             call_deinit(mod);
 348             mod->loaded=FALSE;
 349         }
 350     }
 351 }
 352
 353
 354 bool ioncore_init_module_support()
 355 {
 356     return TRUE;
 357 }
 358
 359
 360 /*}}}*/
 361
 362
 363 #endif
 364
 365
 366 /*{{{ Exports */
 367
 368
 369 /*EXTL_DOC
 370  * Attempt to load a C-side module.
 371  */
 372 EXTL_EXPORT
 373 bool ioncore_load_module(const char *modname)
 374 {
 375     if(modname==NULL){
 376         warn(TR("No module to load given."));
 377         return FALSE;
 378     }
 379     return do_load_module(modname);
 380 }
 381
 382
 383 /*}}}*/
 384