core/modules.c

   1 /*
   2  * modules.c:
   3  *
   4  * Provides functions for dealing with dynamic modules.
   5  */
   6
   7 #include <stdlib.h>
   8 #include <dlfcn.h>
   9 #include "modules.h"
  10 #include "../lib/array.h"
  11 #include "../lib/sstring.h"
  12 #include "../lib/irc_string.h"
  13 #include "../lib/splitline.h"
  14 #include "../lib/strlfunc.h"
  15 #include "config.h"
  16 #include "error.h"
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <errno.h>
  20 #include <unistd.h>
  21 #include "schedule.h"
  22
  23 #define DEPFILE "modules.dep"
  24
  25 #define MAXMODULES 100
  26
  27 /* Module dependency stuff.
  28  *
  29  * "parents" are modules we rely on in order to work.
  30  * Whenever we load a module we must ensure all parents are present first.
  31  *
  32  * "children" are modules which rely on us.
  33  * Whenever we remove a module, we must ensure all children are removed.
  34  * If it's a reload, we will reload them afterwards.
  35  *
  36  * Now, depmod.pl cunningly arranges the file so that each modules' parents are
  37  * always defined earlier in the file.  So we can allocate and fill in the parents
  38  * array as we read the file.  Note that we can also arrange for numchildren to be
  39  * correct on each node when we've finished.
  40  *
  41  * We then do a second pass.  At each node, we allocate the space for the
  42  * children array and reset numchildren to 0.  We can also then populate our
  43  * parents' children array with ourselves, using "numchildren" to get the
  44  * list in order.
  45  *
  46  * At the end of the second pass we should have a correctly filled in array!
  47  */
  48
  49 sstring *safereload_str;
  50 schedule *safereload_sched;
  51
  52 struct module_dep {
  53   sstring *name;
  54   unsigned int numparents;
  55   unsigned int numchildren;
  56   struct module_dep **parents;
  57   struct module_dep **children;
  58   unsigned int reloading;
  59 };
  60
  61 array modules;
  62
  63 struct module_dep moduledeps[MAXMODULES];
  64 unsigned int knownmodules=0;
  65
  66 sstring *moddir;
  67 sstring *modsuffix;
  68
  69 /* Clear out and free the dependencies. */
  70 void clearmoduledeps() {
  71   unsigned int i;
  72
  73   for (i=0;i<knownmodules;i++) {
  74     freesstring(moduledeps[i].name);
  75     if (moduledeps[i].parents) {
  76       free(moduledeps[i].parents);
  77       moduledeps[i].parents=NULL;
  78     }
  79     if (moduledeps[i].children) {
  80       free(moduledeps[i].children);
  81       moduledeps[i].children=NULL;
  82     }
  83   }
  84
  85   knownmodules=0;
  86 }
  87
  88 /* Get a pointer to the given module's dependency record. */
  89 struct module_dep *getmoduledep(const char *name) {
  90   unsigned int i;
  91
  92   for (i=0;i<knownmodules;i++) {
  93     if (!strcmp(name,moduledeps[i].name->content))
  94       return &(moduledeps[i]);
  95   }
  96
  97   return NULL;
  98 }
  99
 100 /* Populate the dependency array.  Read the monster description above for details.
 101  * This relies on moddir being set, so call this after setting it up. */
 102 void initmoduledeps() {
 103   FILE *fp;
 104   char buf[1024];
 105   char *largv[100];
 106   char largc;
 107   char *ch;
 108   struct module_dep *mdp, *tmdp;
 109   unsigned int i,j;
 110
 111   sprintf(buf,"%s/%s",moddir->content,DEPFILE);
 112
 113   if (!(fp=fopen(buf,"r"))) {
 114     Error("core",ERR_WARNING,"Unable to open module dependency file: %s",buf);
 115   } else {
 116     /* First pass */
 117     while (!feof(fp)) {
 118       fgets(buf, sizeof(buf), fp);
 119       if (feof(fp))
 120         break;
 121
 122       /* Chomp off that ruddy newline. */
 123       for (ch=buf;*ch;ch++) {
 124         if (*ch=='\n' || *ch=='\r') {
 125           *ch='\0';
 126           break;
 127         }
 128       }
 129
 130       /* We have a space-delimited list of things.  Whatever will we do with that? :) */
 131       largc=splitline(buf,largv,100,0);
 132
 133       if (largc<1)
 134         continue;
 135
 136       /* Add us to the array */
 137       i=knownmodules++;
 138       if (i>=MAXMODULES) {
 139         Error("core",ERR_ERROR,
 140                "Too many modules in dependency file; rebuild with higher MAXMODULES.  Module dependencies disabled.\n");
 141         clearmoduledeps();
 142         return;
 143       }
 144
 145       mdp=&(moduledeps[i]);
 146
 147       mdp->name=getsstring(largv[0],100);
 148       mdp->numparents=largc-1;
 149       mdp->numchildren=0; /* peace, for now */
 150       mdp->parents=malloc(mdp->numparents * sizeof(struct module_dep *));
 151
 152       /* Fill in the parents array */
 153       for (i=0;i<(largc-1);i++) {
 154         if (!(mdp->parents[i]=getmoduledep(largv[i+1]))) {
 155           Error("core",ERR_WARNING,"Couldn't find parent module %s of %s.  Module dependencies disabled.",
 156                   largv[i+1],largv[0]);
 157           clearmoduledeps();
 158           return;
 159         }
 160         mdp->parents[i]->numchildren++; /* break the bad news */
 161       }
 162     }
 163
 164     /* Second pass */
 165     for (i=0;i<knownmodules;i++) {
 166       mdp=&(moduledeps[i]);
 167
 168       /* Allocate child array */
 169       if (mdp->numchildren) {
 170         mdp->children=malloc(mdp->numchildren * sizeof(struct module_dep *));
 171         mdp->numchildren=0; /* if only real life were this simple */
 172       }
 173
 174       /* Now fill in the children arrays of our parents (bear with me on this) */
 175       for (j=0;j<mdp->numparents;j++) {
 176         tmdp=mdp->parents[j]; /* This is just... */
 177
 178         tmdp->children[tmdp->numchildren++]=mdp; /* ... to give this line a chance at making sense */
 179       }
 180     }
 181   }
 182 }
 183
 184 void modulerehash() {
 185   int i;
 186   sstring **mods;
 187   array *autoloads;
 188
 189   if (moddir!=NULL)
 190     freesstring(moddir);
 191
 192   if (modsuffix!=NULL)
 193     freesstring(modsuffix);
 194
 195   clearmoduledeps();
 196
 197   moddir=getcopyconfigitem("core","moduledir",".",100);
 198   modsuffix=getcopyconfigitem("core","modulesuffix",".so",5);
 199
 200   initmoduledeps();
 201
 202   /* Check for auto-load modules */
 203   autoloads=getconfigitems("core","loadmodule");
 204   if (autoloads!=NULL) {
 205     mods=(sstring **)(autoloads->content);
 206     for (i=0;i<autoloads->cursi;i++) {
 207       insmod(mods[i]->content);
 208     }
 209   }
 210 }
 211
 212 void initmodules() {
 213   array_init(&modules,sizeof(module));
 214   array_setlim1(&modules,5);
 215   array_setlim2(&modules,10);
 216
 217   moddir=NULL;
 218   modsuffix=NULL;
 219   modulerehash();
 220 }
 221
 222 int insmod(char *modulename) {
 223   int i;
 224   module *mods;
 225   char buf[1024];
 226   const char *(*verinfo)(const char **);
 227   struct module_dep *mdp;
 228
 229   delchars(modulename,"./\\;");
 230
 231   if (isloaded(modulename)) {
 232     Error("core",ERR_DEBUG,"Tried to load already loaded module: %s",modulename);
 233     return 1;
 234   }
 235
 236   if (strlen(modulename)>100) {
 237     Error("core",ERR_WARNING,"Module name too long: %s",modulename);
 238     return 1;
 239   }
 240
 241   if ((mdp=getmoduledep(modulename))) {
 242     for (i=0;i<mdp->numparents;i++) {
 243       if (!isloaded(mdp->parents[i]->name->content)) {
 244         if (insmod(mdp->parents[i]->name->content)) {
 245           Error("core",ERR_WARNING,"Error loading dependant module %s (needed by %s)",
 246                    mdp->parents[i]->name->content,modulename);
 247           return 1;
 248         }
 249       }
 250     }
 251   } else {
 252     Error("core",ERR_WARNING,"Loading module %s without dependency information.",modulename);
 253   }
 254
 255   i=array_getfreeslot(&modules);
 256   mods=(module *)(modules.content);
 257
 258   sprintf(buf,"%s/%s%s",moddir->content,modulename,modsuffix->content);
 259
 260   mods[i].handle=dlopen(buf,RTLD_NOW|RTLD_GLOBAL);
 261
 262   if(mods[i].handle==NULL) {
 263     Error("core",ERR_ERROR,"Loading module %s failed: %s",modulename,dlerror());
 264     array_delslot(&modules,i);
 265     return -1;
 266   }
 267
 268   mods[i].name=getsstring(modulename,MODULENAMELEN);
 269
 270   verinfo=dlsym(mods[i].handle,"_version");
 271   if(verinfo) {
 272     mods[i].buildid=verinfo(&mods[i].version);
 273   } else {
 274     mods[i].version=NULL;
 275     mods[i].buildid=NULL;
 276   }
 277
 278   mods[i].loadedsince = time(NULL);
 279   Error("core",ERR_INFO,"Loaded module %s OK.",modulename);
 280
 281   return 0;
 282 }
 283
 284 int getindex(char *modulename) {
 285   int i;
 286   module *mods;
 287
 288   mods=(module *)(modules.content);
 289   for(i=0;i<modules.cursi;i++)
 290     if (!strcmp(mods[i].name->content,modulename))
 291       return i;
 292
 293   return -1;
 294 }
 295
 296 char *lsmod(int index, const char **ver, const char **buildid, time_t *t) {
 297   module *mods;
 298
 299   if (index < 0 || index >= modules.cursi)
 300     return NULL;
 301
 302   mods=(module *)(modules.content);
 303   if(ver)
 304     *ver=mods[index].version;
 305   if(buildid)
 306     *buildid=mods[index].buildid;
 307   if(t)
 308     *t=mods[index].loadedsince;
 309
 310   return mods[index].name->content;
 311 }
 312
 313 int isloaded(char *modulename) {
 314   if (getindex(modulename)==-1)
 315     return 0;
 316   else
 317     return 1;
 318 }
 319
 320
 321 int rmmod(char *modulename) {
 322   int i,j;
 323   module *mods;
 324   struct module_dep *mdp;
 325
 326   delchars(modulename,"./\\;");
 327
 328   i=getindex(modulename);
 329   if (i<0)
 330     return 1;
 331
 332   if ((mdp=getmoduledep(modulename))) {
 333     for (j=0;j<mdp->numchildren;j++) {
 334       if (isloaded(mdp->children[j]->name->content)) {
 335         if (rmmod(mdp->children[j]->name->content)) {
 336           Error("core",ERR_WARNING,"Unable to remove child module %s (depends on %s)",
 337                  mdp->children[j]->name->content, modulename);
 338           return 1;
 339         }
 340       }
 341     }
 342
 343     /* We may have removed other modules - reaquire the index number in case it has changed. */
 344     i=getindex(modulename);
 345     if (i<0)
 346       return 1;
 347   } else {
 348     Error("core",ERR_WARNING,"Removing module %s without dependency information",modulename);
 349   }
 350
 351   mods=(module *)(modules.content);
 352
 353 #ifdef BROKEN_DLCLOSE
 354   {
 355     void (*fini)();
 356     fini = dlsym(mods[i].handle, "__fini");
 357     if(!dlerror())
 358       fini();
 359   }
 360 #endif
 361
 362   dlclose(mods[i].handle);
 363   freesstring(mods[i].name);
 364   array_delslot(&modules,i);
 365
 366   Error("core",ERR_INFO,"Removed module %s.",modulename);
 367
 368   return 0;
 369 }
 370
 371 /* Set the reload mark on the indicated module, if loaded, and all its
 372  * children */
 373 void setreloadmark(struct module_dep *mdp) {
 374   unsigned int i;
 375
 376   if (!isloaded(mdp->name->content))
 377     return;
 378
 379   for (i=0;i<mdp->numchildren;i++)
 380     setreloadmark(mdp->children[i]);
 381
 382   mdp->reloading=1;
 383 }
 384
 385 /* preparereload: this function marks in the dependency tree all the
 386  * modules which will be unloaded if this one is removed. */
 387 void preparereload(char *modulename) {
 388   unsigned int i;
 389   struct module_dep *mdp;
 390
 391   delchars(modulename,"./\\;");
 392
 393   /* First, clear the mark off all dependant modules */
 394   for (i=0;i<knownmodules;i++)
 395     moduledeps[i].reloading=0;
 396
 397   /* Do nothing if this module is not loaded */
 398   i=getindex(modulename);
 399   if (i<0)
 400     return;
 401
 402   if ((mdp=getmoduledep(modulename))) {
 403     setreloadmark(mdp);
 404   }
 405 }
 406
 407 /* reloadmarked: this function loads all the modules marked for reloading.
 408  * The way the array is ordered means we will do this in the "right" order.
 409  * This means we won't do an isloaded() check for each one - we shouldn't
 410  * get any "already loaded" warnings so let them come out if they happen.
 411  */
 412 void reloadmarked(void) {
 413   unsigned int i;
 414
 415   for (i=0;i<knownmodules;i++) {
 416     if (moduledeps[i].reloading) {
 417       insmod(moduledeps[i].name->content);
 418     }
 419   }
 420 }
 421
 422 void safereloadcallback(void *arg) {
 423   safereload_sched=NULL;
 424
 425   if (!safereload_str)
 426     return;
 427
 428   preparereload(safereload_str->content);
 429   rmmod(safereload_str->content);
 430   insmod(safereload_str->content);
 431   reloadmarked();
 432
 433   freesstring(safereload_str);
 434   safereload_str=NULL;
 435 }
 436
 437 void safereload(char *themodule) {
 438   if (safereload_str)
 439     freesstring(safereload_str);
 440
 441   safereload_str=getsstring(themodule, 100);
 442
 443   if (safereload_sched)
 444     deleteschedule(safereload_sched, safereloadcallback, NULL);
 445
 446   scheduleoneshot(1, safereloadcallback, NULL);
 447 }
 448
 449 void newserv_shutdown() {
 450   module *mods;
 451   char buf[1024];
 452
 453   while (modules.cursi) {
 454     mods=(module *)(modules.content);
 455
 456     strlcpy(buf, mods[0].name->content, sizeof(buf));
 457     rmmod(buf);
 458   }
 459
 460   clearmoduledeps();
 461
 462   if (moddir!=NULL)
 463     freesstring(moddir);
 464
 465   if (modsuffix!=NULL)
 466     freesstring(modsuffix);
 467
 468   Error("core",ERR_INFO,"All modules removed.  Exiting.");
 469 }
 470
 471 /* very slow, make sure you cache the pointer! */
 472 void *ndlsym(char *modulename, char *fn) {
 473   module *mods=(module *)(modules.content);
 474   int i=getindex(modulename);
 475
 476   if (i<0)
 477     return NULL;
 478
 479   return dlsym(mods[i].handle, fn);
 480 }