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], modulebuf[1024];
 226   const char *(*verinfo)(const char **);
 227   struct module_dep *mdp;
 228
 229   strlcpy(modulebuf, modulename, sizeof(modulebuf));
 230   delchars(modulebuf,"./\\;");
 231
 232   if (isloaded(modulebuf)) {
 233     Error("core",ERR_DEBUG,"Tried to load already loaded module: %s",modulebuf);
 234     return 1;
 235   }
 236
 237   if (strlen(modulebuf)>100) {
 238     Error("core",ERR_WARNING,"Module name too long: %s",modulebuf);
 239     return 1;
 240   }
 241
 242   if ((mdp=getmoduledep(modulebuf))) {
 243     for (i=0;i<mdp->numparents;i++) {
 244       if (!isloaded(mdp->parents[i]->name->content)) {
 245         if (insmod(mdp->parents[i]->name->content)) {
 246           Error("core",ERR_WARNING,"Error loading dependant module %s (needed by %s)",
 247                    mdp->parents[i]->name->content,modulebuf);
 248           return 1;
 249         }
 250       }
 251     }
 252   } else {
 253     Error("core",ERR_WARNING,"Loading module %s without dependency information.",modulebuf);
 254   }
 255
 256   i=array_getfreeslot(&modules);
 257   mods=(module *)(modules.content);
 258
 259   sprintf(buf,"%s/%s%s",moddir->content,modulebuf,modsuffix->content);
 260
 261   mods[i].handle=dlopen(buf,RTLD_NOW|RTLD_GLOBAL);
 262
 263   if(mods[i].handle==NULL) {
 264     Error("core",ERR_ERROR,"Loading module %s failed: %s",modulebuf,dlerror());
 265     array_delslot(&modules,i);
 266     return -1;
 267   }
 268
 269   mods[i].name=getsstring(modulebuf,MODULENAMELEN);
 270
 271   verinfo=dlsym(mods[i].handle,"_version");
 272   if(verinfo) {
 273     mods[i].buildid=verinfo(&mods[i].version);
 274   } else {
 275     mods[i].version=NULL;
 276     mods[i].buildid=NULL;
 277   }
 278
 279   mods[i].loadedsince = time(NULL);
 280   Error("core",ERR_INFO,"Loaded module %s OK.",modulebuf);
 281
 282   return 0;
 283 }
 284
 285 int getindex(char *modulename) {
 286   int i;
 287   module *mods;
 288
 289   mods=(module *)(modules.content);
 290   for(i=0;i<modules.cursi;i++)
 291     if (!strcmp(mods[i].name->content,modulename))
 292       return i;
 293
 294   return -1;
 295 }
 296
 297 char *lsmod(int index, const char **ver, const char **buildid, time_t *t) {
 298   module *mods;
 299
 300   if (index < 0 || index >= modules.cursi)
 301     return NULL;
 302
 303   mods=(module *)(modules.content);
 304   if(ver)
 305     *ver=mods[index].version;
 306   if(buildid)
 307     *buildid=mods[index].buildid;
 308   if(t)
 309     *t=mods[index].loadedsince;
 310
 311   return mods[index].name->content;
 312 }
 313
 314 int isloaded(char *modulename) {
 315   if (getindex(modulename)==-1)
 316     return 0;
 317   else
 318     return 1;
 319 }
 320
 321
 322 int rmmod(char *modulename) {
 323   int i,j;
 324   module *mods;
 325   struct module_dep *mdp;
 326   char modulebuf[1024];
 327
 328   strlcpy(modulebuf, modulename, sizeof(modulebuf));
 329   delchars(modulebuf,"./\\;");
 330
 331   i=getindex(modulebuf);
 332   if (i<0)
 333     return 1;
 334
 335   if ((mdp=getmoduledep(modulebuf))) {
 336     for (j=0;j<mdp->numchildren;j++) {
 337       if (isloaded(mdp->children[j]->name->content)) {
 338         if (rmmod(mdp->children[j]->name->content)) {
 339           Error("core",ERR_WARNING,"Unable to remove child module %s (depends on %s)",
 340                  mdp->children[j]->name->content, modulebuf);
 341           return 1;
 342         }
 343       }
 344     }
 345
 346     /* We may have removed other modules - reaquire the index number in case it has changed. */
 347     i=getindex(modulebuf);
 348     if (i<0)
 349       return 1;
 350   } else {
 351     Error("core",ERR_WARNING,"Removing module %s without dependency information",modulebuf);
 352   }
 353
 354   mods=(module *)(modules.content);
 355
 356 #ifdef BROKEN_DLCLOSE
 357   {
 358     void (*fini)();
 359     fini = dlsym(mods[i].handle, "__fini");
 360     if(!dlerror())
 361       fini();
 362   }
 363 #endif
 364
 365   dlclose(mods[i].handle);
 366   freesstring(mods[i].name);
 367   array_delslot(&modules,i);
 368
 369   Error("core",ERR_INFO,"Removed module %s.",modulebuf);
 370
 371   return 0;
 372 }
 373
 374 /* Set the reload mark on the indicated module, if loaded, and all its
 375  * children */
 376 void setreloadmark(struct module_dep *mdp) {
 377   unsigned int i;
 378
 379   if (!isloaded(mdp->name->content))
 380     return;
 381
 382   for (i=0;i<mdp->numchildren;i++)
 383     setreloadmark(mdp->children[i]);
 384
 385   mdp->reloading=1;
 386 }
 387
 388 /* preparereload: this function marks in the dependency tree all the
 389  * modules which will be unloaded if this one is removed. */
 390 void preparereload(char *modulename) {
 391   unsigned int i;
 392   struct module_dep *mdp;
 393   char modulebuf[1024];
 394
 395   strlcpy(modulebuf, modulename, sizeof(modulebuf));
 396   delchars(modulebuf,"./\\;");
 397
 398   /* First, clear the mark off all dependant modules */
 399   for (i=0;i<knownmodules;i++)
 400     moduledeps[i].reloading=0;
 401
 402   /* Do nothing if this module is not loaded */
 403   if (getindex(modulebuf)<0)
 404     return;
 405
 406   if ((mdp=getmoduledep(modulebuf))) {
 407     setreloadmark(mdp);
 408   }
 409 }
 410
 411 /* reloadmarked: this function loads all the modules marked for reloading.
 412  * The way the array is ordered means we will do this in the "right" order.
 413  * This means we won't do an isloaded() check for each one - we shouldn't
 414  * get any "already loaded" warnings so let them come out if they happen.
 415  */
 416 void reloadmarked(void) {
 417   unsigned int i;
 418
 419   for (i=0;i<knownmodules;i++) {
 420     if (moduledeps[i].reloading) {
 421       insmod(moduledeps[i].name->content);
 422     }
 423   }
 424 }
 425
 426 void safereloadcallback(void *arg) {
 427   safereload_sched=NULL;
 428
 429   if (!safereload_str)
 430     return;
 431
 432   preparereload(safereload_str->content);
 433   rmmod(safereload_str->content);
 434   insmod(safereload_str->content);
 435   reloadmarked();
 436
 437   freesstring(safereload_str);
 438   safereload_str=NULL;
 439 }
 440
 441 void safereload(char *themodule) {
 442   if (safereload_str)
 443     freesstring(safereload_str);
 444
 445   safereload_str=getsstring(themodule, 100);
 446
 447   if (safereload_sched)
 448     deleteschedule(safereload_sched, safereloadcallback, NULL);
 449
 450   scheduleoneshot(1, safereloadcallback, NULL);
 451 }
 452
 453 void newserv_shutdown() {
 454   module *mods;
 455   char buf[1024];
 456
 457   while (modules.cursi) {
 458     mods=(module *)(modules.content);
 459
 460     strlcpy(buf, mods[0].name->content, sizeof(buf));
 461     rmmod(buf);
 462   }
 463
 464   clearmoduledeps();
 465
 466   if (moddir!=NULL)
 467     freesstring(moddir);
 468
 469   if (modsuffix!=NULL)
 470     freesstring(modsuffix);
 471
 472   Error("core",ERR_INFO,"All modules removed.  Exiting.");
 473 }
 474
 475 /* very slow, make sure you cache the pointer! */
 476 void *ndlsym(char *modulename, char *fn) {
 477   module *mods=(module *)(modules.content);
 478   int i=getindex(modulename);
 479
 480   if (i<0)
 481     return NULL;
 482
 483   return dlsym(mods[i].handle, fn);
 484 }