src/modules.c

   1 /*
   2  * ion/modules.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #ifndef CF_NO_MODULE_SUPPORT
   9
  10 #include <dlfcn.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13
  14 #include "common.h"
  15 #include "modules.h"
  16
  17
  18 INTRSTRUCT(Module)
  19
  20 DECLSTRUCT(Module){
  21         void *handle;
  22         char *name;
  23         Module *next;
  24 };
  25
  26 static Module *modules=NULL, *last_module=NULL;
  27 static size_t longest_name=0;
  28
  29
  30 /*{{{ Loading and initialization code */
  31
  32
  33 static bool call_init(void *handle, char *name)
  34 {
  35         char *p=scat(name, "_init");
  36         bool (*initfn)(void);
  37
  38         if(p==NULL){
  39                 warn_err();
  40                 return FALSE;
  41         }
  42
  43         initfn=(bool (*)())dlsym(handle, p);
  44
  45         free(p);
  46
  47         if(initfn==NULL)
  48                 return TRUE;
  49
  50         return initfn();
  51 }
  52
  53
  54 bool load_module(const char *fname)
  55 {
  56         void *handle;
  57         Module *m;
  58         const char *p;
  59         char *n;
  60         size_t l;
  61
  62         handle=dlopen(fname, RTLD_LAZY);
  63
  64         if(handle==NULL){
  65                 warn_obj(fname, "%s", dlerror());
  66                 return FALSE;
  67         }
  68
  69         /* Get the module name without directory or extension */
  70
  71         p=strrchr(fname, '/');
  72
  73         if(p!=NULL)
  74                 fname=p+1;
  75
  76         for(p=fname; *p!='\0'; p++){
  77                 if(!isalnum(*p) && *p!='_')
  78                         break;
  79         }
  80
  81         n=ALLOC_N(char, p-fname);
  82
  83         if(n==NULL){
  84                 warn_err();
  85                 goto err1;
  86         }
  87
  88         memcpy(n, fname, p-fname);
  89         n[p-fname]='\0';
  90
  91         if(!call_init(handle, n))
  92                 goto err2;
  93
  94         /* Allocate space for module info */
  95
  96         m=ALLOC(Module);
  97
  98         if(m==NULL){
  99                 warn_err();
 100                 goto err2;
 101         }
 102
 103         m->name=n;
 104         m->handle=handle;
 105         m->next=NULL;
 106
 107         if(last_module==NULL){
 108                 modules=last_module=m;
 109         }else{
 110                 last_module->next=m;
 111                 last_module=m;
 112         }
 113
 114         l=strlen(n);
 115
 116         if(l>longest_name)
 117                 longest_name=l;
 118
 119         return TRUE;
 120
 121 err2:
 122         free(n);
 123 err1:
 124         dlclose(handle);
 125         return FALSE;
 126 }
 127
 128
 129 /*}}}*/
 130
 131
 132 /*{{{ Deinit */
 133
 134
 135 static void call_deinit(void *handle, char *name)
 136 {
 137         char *p=scat(name, "_deinit");
 138         void (*deinitfn)(void);
 139
 140         if(p==NULL){
 141                 warn_err();
 142                 return;
 143         }
 144
 145         deinitfn=(void (*)())dlsym(handle, p);
 146
 147         free(p);
 148
 149         if(deinitfn!=NULL)
 150                 deinitfn();
 151 }
 152
 153
 154 static void do_unload_module(Module *m)
 155 {
 156         call_deinit(m->handle, m->name);
 157
 158         dlclose(m->handle);
 159         if(m->name!=NULL)
 160                 free(m->name);
 161         free(m);
 162 }
 163
 164
 165 void unload_modules()
 166 {
 167         Module *m, *next;
 168
 169         for(m=modules; m!=NULL; m=next){
 170                 next=m->next;
 171                 do_unload_module(m);
 172         }
 173         modules=NULL;
 174         last_module=NULL;
 175         longest_name=0;
 176 }
 177
 178
 179 /*}}}*/
 180
 181
 182 /*{{{ Hooks and iterative symbol lookup */
 183
 184
 185 static char *symtmp=NULL;
 186 static Module *cmod=NULL;
 187
 188
 189 static void *get_sym(const Module *m, const char *sym)
 190 {
 191         sprintf(symtmp, "%s_%s", m->name, sym);
 192         return dlsym(m->handle, symtmp);
 193 }
 194
 195
 196 void *miter_begin(const char *sym)
 197 {
 198         cmod=NULL;
 199
 200         if(modules==NULL)
 201                 return NULL;
 202
 203         symtmp=ALLOC_N(char, strlen(sym)+longest_name+1+1);
 204
 205         if(symtmp==NULL){
 206                 warn_err();
 207                 return NULL;
 208         }
 209
 210         cmod=modules;
 211
 212         return miter_next(sym);
 213 }
 214
 215
 216 void *miter_next(const char *sym)
 217 {
 218         void *r;
 219
 220         do{
 221                 if(cmod==NULL)
 222                         return NULL;
 223
 224                 r=get_sym(cmod, sym);
 225                 cmod=cmod->next;
 226         }while(r==NULL);
 227
 228         return r;
 229 }
 230
 231
 232 void miter_end()
 233 {
 234         if(symtmp!=NULL){
 235                 free(symtmp);
 236                 symtmp=NULL;
 237         }
 238 }
 239
 240
 241 void call_hooks(const char *hook)
 242 {
 243         void (*fn)();
 244
 245         for(fn=(void (*)())miter_begin(hook);
 246                 fn!=NULL;
 247                 fn=(void (*)())miter_next(hook)){
 248
 249                 fn();
 250         }
 251
 252         miter_end();
 253 }
 254
 255
 256 void call_hooks_p(const char *hook, void *p)
 257 {
 258         void (*fn)(void *);
 259
 260         for(fn=(void (*)(void *))miter_begin(hook);
 261                 fn!=NULL;
 262                 fn=(void (*)(void *))miter_next(hook)){
 263
 264                 fn(p);
 265         }
 266
 267         miter_end();
 268 }
 269
 270
 271 /*}}}*/
 272
 273
 274 #else /* CF_MODULE_SUPPORT */
 275
 276
 277 #include "common.h"
 278
 279
 280 /*{{{ Dummy functions for systems without sufficient dynamic
 281  * linking support
 282  */
 283
 284 bool load_module(const char *name)
 285 {
 286         warn_obj(name, "Unabled to load: module support not enabled.");
 287         return FALSE;
 288 }
 289
 290
 291 void unload_modules()
 292 {
 293
 294 }
 295
 296
 297 void call_hooks(const char *hook)
 298 {
 299
 300 }
 301
 302
 303 void call_hooks_p(const char *hook, void *p)
 304 {
 305
 306 }
 307
 308
 309 void *miter_begin(const char *sym)
 310 {
 311         return NULL;
 312 }
 313
 314
 315 void *miter_next(const char *sym)
 316 {
 317         return NULL;
 318 }
 319
 320
 321 void miter_end()
 322 {
 323
 324 }
 325
 326
 327 /*}}}*/
 328
 329
 330 #endif