src/modules.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  modules.c: A module loader.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  *
  24  *  $Id: modules.c 3161 2007-01-25 07:23:01Z nenolod $
  25  */
  26
  27 #include "stdinc.h"
  28
  29
  30 #include "modules.h"
  31 #include "logger.h"
  32 #include "ircd.h"
  33 #include "client.h"
  34 #include "send.h"
  35 #include "s_conf.h"
  36 #include "s_newconf.h"
  37 #include "numeric.h"
  38 #include "parse.h"
  39 #include "ircd_defs.h"
  40 #include "match.h"
  41
  42
  43
  44 /* -TimeMr14C:
  45  * I have moved the dl* function definitions and
  46  * the two functions (load_a_module / unload_a_module) to the
  47  * file dynlink.c
  48  * And also made the necessary changes to those functions
  49  * to comply with shl_load and friends.
  50  * In this file, to keep consistency with the makefile,
  51  * I added the ability to load *.sl files, too.
  52  * 27/02/2002
  53  */
  54
  55 #ifndef STATIC_MODULES
  56
  57 struct module **modlist = NULL;
  58
  59 static const char *core_module_table[] = {
  60         "m_die",
  61         "m_error",
  62         "m_join",
  63         "m_kick",
  64         "m_kill",
  65         "m_message",
  66         "m_mode",
  67         "m_nick",
  68         "m_part",
  69         "m_quit",
  70         "m_server",
  71         "m_squit",
  72         NULL
  73 };
  74
  75 #define MODS_INCREMENT 10
  76 int num_mods = 0;
  77 int max_mods = MODS_INCREMENT;
  78
  79 static rb_dlink_list mod_paths;
  80
  81 static int mo_modload(struct Client *, struct Client *, int, const char **);
  82 static int mo_modlist(struct Client *, struct Client *, int, const char **);
  83 static int mo_modreload(struct Client *, struct Client *, int, const char **);
  84 static int mo_modunload(struct Client *, struct Client *, int, const char **);
  85 static int mo_modrestart(struct Client *, struct Client *, int, const char **);
  86
  87 struct Message modload_msgtab = {
  88         "MODLOAD", 0, 0, 0, MFLG_SLOW,
  89         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_modload, 2}}
  90 };
  91
  92 struct Message modunload_msgtab = {
  93         "MODUNLOAD", 0, 0, 0, MFLG_SLOW,
  94         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_modunload, 2}}
  95 };
  96
  97 struct Message modreload_msgtab = {
  98         "MODRELOAD", 0, 0, 0, MFLG_SLOW,
  99         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_modreload, 2}}
 100 };
 101
 102 struct Message modlist_msgtab = {
 103         "MODLIST", 0, 0, 0, MFLG_SLOW,
 104         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_modlist, 0}}
 105 };
 106
 107 struct Message modrestart_msgtab = {
 108         "MODRESTART", 0, 0, 0, MFLG_SLOW,
 109         {mg_unreg, mg_not_oper, mg_ignore, mg_ignore, mg_ignore, {mo_modrestart, 0}}
 110 };
 111
 112 void
 113 modules_init(void)
 114 {
 115         mod_add_cmd(&modload_msgtab);
 116         mod_add_cmd(&modunload_msgtab);
 117         mod_add_cmd(&modreload_msgtab);
 118         mod_add_cmd(&modlist_msgtab);
 119         mod_add_cmd(&modrestart_msgtab);
 120
 121         /* Add the default paths we look in to the module system --nenolod */
 122         mod_add_path(MODPATH);
 123         mod_add_path(AUTOMODPATH);
 124 }
 125
 126 /* mod_find_path()
 127  *
 128  * input        - path
 129  * output       - none
 130  * side effects - returns a module path from path
 131  */
 132 static struct module_path *
 133 mod_find_path(const char *path)
 134 {
 135         rb_dlink_node *ptr;
 136         struct module_path *mpath;
 137
 138         RB_DLINK_FOREACH(ptr, mod_paths.head)
 139         {
 140                 mpath = ptr->data;
 141
 142                 if(!strcmp(path, mpath->path))
 143                         return mpath;
 144         }
 145
 146         return NULL;
 147 }
 148
 149 /* mod_add_path
 150  *
 151  * input        - path
 152  * ouput        -
 153  * side effects - adds path to list
 154  */
 155 void
 156 mod_add_path(const char *path)
 157 {
 158         struct module_path *pathst;
 159
 160         if(mod_find_path(path))
 161                 return;
 162
 163         pathst = rb_malloc(sizeof(struct module_path));
 164
 165         strcpy(pathst->path, path);
 166         rb_dlinkAddAlloc(pathst, &mod_paths);
 167 }
 168
 169 /* mod_clear_paths()
 170  *
 171  * input        -
 172  * output       -
 173  * side effects - clear the lists of paths
 174  */
 175 void
 176 mod_clear_paths(void)
 177 {
 178         rb_dlink_node *ptr, *next_ptr;
 179
 180         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
 181         {
 182                 rb_free(ptr->data);
 183                 rb_free_rb_dlink_node(ptr);
 184         }
 185
 186         mod_paths.head = mod_paths.tail = NULL;
 187         mod_paths.length = 0;
 188 }
 189
 190 /* findmodule_byname
 191  *
 192  * input        -
 193  * output       -
 194  * side effects -
 195  */
 196
 197 int
 198 findmodule_byname(const char *name)
 199 {
 200         int i;
 201
 202         for (i = 0; i < num_mods; i++)
 203         {
 204                 if(!irccmp(modlist[i]->name, name))
 205                         return i;
 206         }
 207         return -1;
 208 }
 209
 210 /* load_all_modules()
 211  *
 212  * input        -
 213  * output       -
 214  * side effects -
 215  */
 216 void
 217 load_all_modules(int warn)
 218 {
 219         DIR *system_module_dir = NULL;
 220         struct dirent *ldirent = NULL;
 221         char module_fq_name[PATH_MAX + 1];
 222         int len;
 223
 224         modules_init();
 225
 226         modlist = (struct module **) rb_malloc(sizeof(struct module) * (MODS_INCREMENT));
 227
 228         max_mods = MODS_INCREMENT;
 229
 230         system_module_dir = opendir(AUTOMODPATH);
 231
 232         if(system_module_dir == NULL)
 233         {
 234                 ilog(L_MAIN, "Could not load modules from %s: %s", AUTOMODPATH, strerror(errno));
 235                 return;
 236         }
 237
 238         while ((ldirent = readdir(system_module_dir)) != NULL)
 239         {
 240                 len = strlen(ldirent->d_name);
 241                 if((len > 3) && !strcmp(ldirent->d_name+len-3, SHARED_SUFFIX))
 242                 {
 243                         (void) rb_snprintf(module_fq_name, sizeof(module_fq_name), "%s/%s", AUTOMODPATH, ldirent->d_name);
 244                         (void) load_a_module(module_fq_name, warn, 0);
 245                 }
 246
 247         }
 248         (void) closedir(system_module_dir);
 249 }
 250
 251 /* load_core_modules()
 252  *
 253  * input        -
 254  * output       -
 255  * side effects - core modules are loaded, if any fail, kill ircd
 256  */
 257 void
 258 load_core_modules(int warn)
 259 {
 260         char module_name[MAXPATHLEN];
 261         int i;
 262
 263
 264         for (i = 0; core_module_table[i]; i++)
 265         {
 266                 rb_snprintf(module_name, sizeof(module_name), "%s/%s%s", MODPATH,
 267                             core_module_table[i], SHARED_SUFFIX);
 268
 269                 if(load_a_module(module_name, warn, 1) == -1)
 270                 {
 271                         ilog(L_MAIN,
 272                              "Error loading core module %s%s: terminating ircd",
 273                              core_module_table[i], SHARED_SUFFIX);
 274                         exit(0);
 275                 }
 276         }
 277 }
 278
 279 /* load_one_module()
 280  *
 281  * input        -
 282  * output       -
 283  * side effects -
 284  */
 285 int
 286 load_one_module(const char *path, int coremodule)
 287 {
 288         char modpath[MAXPATHLEN];
 289         rb_dlink_node *pathst;
 290         struct module_path *mpath;
 291
 292         struct stat statbuf;
 293
 294         if (server_state_foreground == 1)
 295                 inotice("loading module %s ...", path);
 296
 297         RB_DLINK_FOREACH(pathst, mod_paths.head)
 298         {
 299                 mpath = pathst->data;
 300
 301                 rb_snprintf(modpath, sizeof(modpath), "%s/%s", mpath->path, path);
 302                 if((strstr(modpath, "../") == NULL) && (strstr(modpath, "/..") == NULL))
 303                 {
 304                         if(stat(modpath, &statbuf) == 0)
 305                         {
 306                                 if(S_ISREG(statbuf.st_mode))
 307                                 {
 308                                         /* Regular files only please */
 309                                         if(coremodule)
 310                                                 return load_a_module(modpath, 1, 1);
 311                                         else
 312                                                 return load_a_module(modpath, 1, 0);
 313                                 }
 314                         }
 315
 316                 }
 317         }
 318
 319         sendto_realops_snomask(SNO_GENERAL, L_ALL, "Cannot locate module %s", path);
 320         return -1;
 321 }
 322
 323
 324 /* load a module .. */
 325 static int
 326 mo_modload(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 327 {
 328         char *m_bn;
 329
 330         if(!IsOperAdmin(source_p))
 331         {
 332                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 333                            me.name, source_p->name, "admin");
 334                 return 0;
 335         }
 336
 337         m_bn = rb_basename(parv[1]);
 338
 339         if(findmodule_byname(m_bn) != -1)
 340         {
 341                 sendto_one_notice(source_p, ":Module %s is already loaded", m_bn);
 342                 rb_free(m_bn);
 343                 return 0;
 344         }
 345
 346         load_one_module(parv[1], 0);
 347
 348         rb_free(m_bn);
 349
 350         return 0;
 351 }
 352
 353
 354 /* unload a module .. */
 355 static int
 356 mo_modunload(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 357 {
 358         char *m_bn;
 359         int modindex;
 360
 361         if(!IsOperAdmin(source_p))
 362         {
 363                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 364                            me.name, source_p->name, "admin");
 365                 return 0;
 366         }
 367
 368         m_bn = rb_basename(parv[1]);
 369
 370         if((modindex = findmodule_byname(m_bn)) == -1)
 371         {
 372                 sendto_one_notice(source_p, ":Module %s is not loaded", m_bn);
 373                 rb_free(m_bn);
 374                 return 0;
 375         }
 376
 377         if(modlist[modindex]->core == 1)
 378         {
 379                 sendto_one_notice(source_p, ":Module %s is a core module and may not be unloaded", m_bn);
 380                 rb_free(m_bn);
 381                 return 0;
 382         }
 383
 384         if(unload_one_module(m_bn, 1) == -1)
 385         {
 386                 sendto_one_notice(source_p, ":Module %s is not loaded", m_bn);
 387         }
 388
 389         rb_free(m_bn);
 390         return 0;
 391 }
 392
 393 /* unload and load in one! */
 394 static int
 395 mo_modreload(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 396 {
 397         char *m_bn;
 398         int modindex;
 399         int check_core;
 400
 401         if(!IsOperAdmin(source_p))
 402         {
 403                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 404                            me.name, source_p->name, "admin");
 405                 return 0;
 406         }
 407
 408         m_bn = rb_basename(parv[1]);
 409
 410         if((modindex = findmodule_byname(m_bn)) == -1)
 411         {
 412                 sendto_one_notice(source_p, ":Module %s is not loaded", m_bn);
 413                 rb_free(m_bn);
 414                 return 0;
 415         }
 416
 417         check_core = modlist[modindex]->core;
 418
 419         if(unload_one_module(m_bn, 1) == -1)
 420         {
 421                 sendto_one_notice(source_p, ":Module %s is not loaded", m_bn);
 422                 rb_free(m_bn);
 423                 return 0;
 424         }
 425
 426         if((load_one_module(m_bn, check_core) == -1) && check_core)
 427         {
 428                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 429                                      "Error reloading core module: %s: terminating ircd", m_bn);
 430                 ilog(L_MAIN, "Error loading core module %s: terminating ircd", m_bn);
 431                 exit(0);
 432         }
 433
 434         rb_free(m_bn);
 435         return 0;
 436 }
 437
 438 /* list modules .. */
 439 static int
 440 mo_modlist(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 441 {
 442         int i;
 443
 444         if(!IsOperAdmin(source_p))
 445         {
 446                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 447                            me.name, source_p->name, "admin");
 448                 return 0;
 449         }
 450
 451         for (i = 0; i < num_mods; i++)
 452         {
 453                 if(parc > 1)
 454                 {
 455                         if(match(parv[1], modlist[i]->name))
 456                         {
 457                                 sendto_one(source_p, form_str(RPL_MODLIST),
 458                                            me.name, source_p->name,
 459                                            modlist[i]->name,
 460                                            modlist[i]->address,
 461                                            modlist[i]->version, modlist[i]->core ? "(core)" : "");
 462                         }
 463                 }
 464                 else
 465                 {
 466                         sendto_one(source_p, form_str(RPL_MODLIST),
 467                                    me.name, source_p->name, modlist[i]->name,
 468                                    modlist[i]->address, modlist[i]->version,
 469                                    modlist[i]->core ? "(core)" : "");
 470                 }
 471         }
 472
 473         sendto_one(source_p, form_str(RPL_ENDOFMODLIST), me.name, source_p->name);
 474         return 0;
 475 }
 476
 477 /* unload and reload all modules */
 478 static int
 479 mo_modrestart(struct Client *client_p, struct Client *source_p, int parc, const char **parv)
 480 {
 481         int modnum;
 482
 483         if(!IsOperAdmin(source_p))
 484         {
 485                 sendto_one(source_p, form_str(ERR_NOPRIVS),
 486                            me.name, source_p->name, "admin");
 487                 return 0;
 488         }
 489
 490         sendto_one_notice(source_p, ":Reloading all modules");
 491
 492         modnum = num_mods;
 493         while (num_mods)
 494                 unload_one_module(modlist[0]->name, 0);
 495
 496         load_all_modules(0);
 497         load_core_modules(0);
 498         rehash(0);
 499
 500         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 501                              "Module Restart: %d modules unloaded, %d modules loaded",
 502                              modnum, num_mods);
 503         ilog(L_MAIN, "Module Restart: %d modules unloaded, %d modules loaded", modnum, num_mods);
 504         return 0;
 505 }
 506
 507
 508
 509 #ifndef RTLD_NOW
 510 #define RTLD_NOW RTLD_LAZY      /* openbsd deficiency */
 511 #endif
 512
 513 #ifndef RTLD_LOCAL
 514 #define RTLD_LOCAL 0
 515 #endif
 516
 517 #ifdef CHARYBDIS_PROFILE
 518 # ifndef RTLD_PROFILE
 519 #  warning libdl may not support profiling, sucks. :(
 520 #  define RTLD_PROFILE 0
 521 # endif
 522 #endif
 523
 524 static void increase_modlist(void);
 525
 526 #define MODS_INCREMENT 10
 527
 528 static char unknown_ver[] = "<unknown>";
 529
 530 /* This file contains the core functions to use dynamic libraries.
 531  * -TimeMr14C
 532  */
 533
 534
 535 #ifdef HAVE_MACH_O_DYLD_H
 536 /*
 537 ** jmallett's dl*(3) shims for NSModule(3) systems.
 538 */
 539 #include <mach-o/dyld.h>
 540
 541 #ifndef HAVE_DLOPEN
 542 #ifndef RTLD_LAZY
 543 #define RTLD_LAZY 2185          /* built-in dl*(3) don't care */
 544 #endif
 545
 546 void undefinedErrorHandler(const char *);
 547 NSModule multipleErrorHandler(NSSymbol, NSModule, NSModule);
 548 void linkEditErrorHandler(NSLinkEditErrors, int, const char *, const char *);
 549 char *dlerror(void);
 550 void *dlopen(char *, int);
 551 int dlclose(void *);
 552 void *dlsym(void *, char *);
 553
 554 static int firstLoad = TRUE;
 555 static int myDlError;
 556 static char *myErrorTable[] = { "Loading file as object failed\n",
 557         "Loading file as object succeeded\n",
 558         "Not a valid shared object\n",
 559         "Architecture of object invalid on this architecture\n",
 560         "Invalid or corrupt image\n",
 561         "Could not access object\n",
 562         "NSCreateObjectFileImageFromFile failed\n",
 563         NULL
 564 };
 565
 566 void
 567 undefinedErrorHandler(const char *symbolName)
 568 {
 569         sendto_realops_snomask(SNO_GENERAL, L_ALL, "Undefined symbol: %s", symbolName);
 570         ilog(L_MAIN, "Undefined symbol: %s", symbolName);
 571         return;
 572 }
 573
 574 NSModule
 575 multipleErrorHandler(NSSymbol s, NSModule old, NSModule new)
 576 {
 577         /* XXX
 578          ** This results in substantial leaking of memory... Should free one
 579          ** module, maybe?
 580          */
 581         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 582                              "Symbol `%s' found in `%s' and `%s'",
 583                              NSNameOfSymbol(s), NSNameOfModule(old), NSNameOfModule(new));
 584         ilog(L_MAIN, "Symbol `%s' found in `%s' and `%s'",
 585              NSNameOfSymbol(s), NSNameOfModule(old), NSNameOfModule(new));
 586         /* We return which module should be considered valid, I believe */
 587         return new;
 588 }
 589
 590 void
 591 linkEditErrorHandler(NSLinkEditErrors errorClass, int errnum,
 592                      const char *fileName, const char *errorString)
 593 {
 594         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 595                              "Link editor error: %s for %s", errorString, fileName);
 596         ilog(L_MAIN, "Link editor error: %s for %s", errorString, fileName);
 597         return;
 598 }
 599
 600 char *
 601 dlerror(void)
 602 {
 603         return myDlError == NSObjectFileImageSuccess ? NULL : myErrorTable[myDlError % 7];
 604 }
 605
 606 void *
 607 dlopen(char *filename, int unused)
 608 {
 609         NSObjectFileImage myImage;
 610         NSModule myModule;
 611
 612         if(firstLoad)
 613         {
 614                 /*
 615                  ** If we are loading our first symbol (huzzah!) we should go ahead
 616                  ** and install link editor error handling!
 617                  */
 618                 NSLinkEditErrorHandlers linkEditorErrorHandlers;
 619
 620                 linkEditorErrorHandlers.undefined = undefinedErrorHandler;
 621                 linkEditorErrorHandlers.multiple = multipleErrorHandler;
 622                 linkEditorErrorHandlers.linkEdit = linkEditErrorHandler;
 623                 NSInstallLinkEditErrorHandlers(&linkEditorErrorHandlers);
 624                 firstLoad = FALSE;
 625         }
 626         myDlError = NSCreateObjectFileImageFromFile(filename, &myImage);
 627         if(myDlError != NSObjectFileImageSuccess)
 628         {
 629                 return NULL;
 630         }
 631         myModule = NSLinkModule(myImage, filename, NSLINKMODULE_OPTION_PRIVATE);
 632         return (void *) myModule;
 633 }
 634
 635 int
 636 dlclose(void *myModule)
 637 {
 638         NSUnLinkModule(myModule, FALSE);
 639         return 0;
 640 }
 641
 642 void *
 643 dlsym(void *myModule, char *mySymbolName)
 644 {
 645         NSSymbol mySymbol;
 646
 647         mySymbol = NSLookupSymbolInModule((NSModule) myModule, mySymbolName);
 648         return NSAddressOfSymbol(mySymbol);
 649 }
 650 #endif
 651 #endif
 652
 653
 654 /*
 655  * HPUX dl compat functions
 656  */
 657 #if defined(HAVE_SHL_LOAD) && !defined(HAVE_DLOPEN)
 658 #define RTLD_LAZY BIND_DEFERRED
 659 #define RTLD_GLOBAL DYNAMIC_PATH
 660 #define dlopen(file,mode) (void *)shl_load((file), (mode), (long) 0)
 661 #define dlclose(handle) shl_unload((shl_t)(handle))
 662 #define dlsym(handle,name) hpux_dlsym(handle,name)
 663 #define dlerror() strerror(errno)
 664
 665 static void *
 666 hpux_dlsym(void *handle, char *name)
 667 {
 668         void *sym_addr;
 669         if(!shl_findsym((shl_t *) & handle, name, TYPE_UNDEFINED, &sym_addr))
 670                 return sym_addr;
 671         return NULL;
 672 }
 673
 674 #endif
 675
 676 /* unload_one_module()
 677  *
 678  * inputs       - name of module to unload
 679  *              - 1 to say modules unloaded, 0 to not
 680  * output       - 0 if successful, -1 if error
 681  * side effects - module is unloaded
 682  */
 683 int
 684 unload_one_module(const char *name, int warn)
 685 {
 686         int modindex;
 687
 688         if((modindex = findmodule_byname(name)) == -1)
 689                 return -1;
 690
 691         /*
 692          ** XXX - The type system in C does not allow direct conversion between
 693          ** data and function pointers, but as it happens, most C compilers will
 694          ** safely do this, however it is a theoretical overlow to cast as we
 695          ** must do here.  I have library functions to take care of this, but
 696          ** despite being more "correct" for the C language, this is more
 697          ** practical.  Removing the abuse of the ability to cast ANY pointer
 698          ** to and from an integer value here will break some compilers.
 699          **          -jmallett
 700          */
 701         /* Left the comment in but the code isn't here any more         -larne */
 702         switch (modlist[modindex]->mapi_version)
 703         {
 704         case 1:
 705                 {
 706                         struct mapi_mheader_av1 *mheader = modlist[modindex]->mapi_header;
 707                         if(mheader->mapi_command_list)
 708                         {
 709                                 struct Message **m;
 710                                 for (m = mheader->mapi_command_list; *m; ++m)
 711                                         mod_del_cmd(*m);
 712                         }
 713
 714                         /* hook events are never removed, we simply lose the
 715                          * ability to call them --fl
 716                          */
 717                         if(mheader->mapi_hfn_list)
 718                         {
 719                                 mapi_hfn_list_av1 *m;
 720                                 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
 721                                         remove_hook(m->hapi_name, m->fn);
 722                         }
 723
 724                         if(mheader->mapi_unregister)
 725                                 mheader->mapi_unregister();
 726                         break;
 727                 }
 728         default:
 729                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 730                                      "Unknown/unsupported MAPI version %d when unloading %s!",
 731                                      modlist[modindex]->mapi_version, modlist[modindex]->name);
 732                 ilog(L_MAIN, "Unknown/unsupported MAPI version %d when unloading %s!",
 733                      modlist[modindex]->mapi_version, modlist[modindex]->name);
 734                 break;
 735         }
 736
 737         dlclose(modlist[modindex]->address);
 738
 739         rb_free(modlist[modindex]->name);
 740         memcpy(&modlist[modindex], &modlist[modindex + 1],
 741                sizeof(struct module) * ((num_mods - 1) - modindex));
 742
 743         if(num_mods != 0)
 744                 num_mods--;
 745
 746         if(warn == 1)
 747         {
 748                 ilog(L_MAIN, "Module %s unloaded", name);
 749                 sendto_realops_snomask(SNO_GENERAL, L_ALL, "Module %s unloaded", name);
 750         }
 751
 752         return 0;
 753 }
 754
 755
 756 /*
 757  * load_a_module()
 758  *
 759  * inputs       - path name of module, int to notice, int of core
 760  * output       - -1 if error 0 if success
 761  * side effects - loads a module if successful
 762  */
 763 int
 764 load_a_module(const char *path, int warn, int core)
 765 {
 766         void *tmpptr = NULL;
 767
 768         char *mod_basename;
 769         const char *ver;
 770
 771         int *mapi_version;
 772
 773         mod_basename = rb_basename(path);
 774
 775 #ifdef CHARYBDIS_PROFILE
 776         tmpptr = dlopen(path, RTLD_NOW | RTLD_LOCAL | RTLD_PROFILE);
 777 #else
 778         tmpptr = dlopen(path, RTLD_NOW | RTLD_LOCAL);
 779 #endif
 780
 781         if(tmpptr == NULL)
 782         {
 783                 const char *err = dlerror();
 784
 785                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 786                                      "Error loading module %s: %s", mod_basename, err);
 787                 ilog(L_MAIN, "Error loading module %s: %s", mod_basename, err);
 788                 rb_free(mod_basename);
 789                 return -1;
 790         }
 791
 792
 793         /*
 794          * _mheader is actually a struct mapi_mheader_*, but mapi_version
 795          * is always the first member of this structure, so we treate it
 796          * as a single int in order to determine the API version.
 797          *      -larne.
 798          */
 799         mapi_version = (int *) (uintptr_t) dlsym(tmpptr, "_mheader");
 800         if((mapi_version == NULL
 801             && (mapi_version = (int *) (uintptr_t) dlsym(tmpptr, "__mheader")) == NULL)
 802            || MAPI_MAGIC(*mapi_version) != MAPI_MAGIC_HDR)
 803         {
 804                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 805                                      "Data format error: module %s has no MAPI header.",
 806                                      mod_basename);
 807                 ilog(L_MAIN, "Data format error: module %s has no MAPI header.", mod_basename);
 808                 (void) dlclose(tmpptr);
 809                 rb_free(mod_basename);
 810                 return -1;
 811         }
 812
 813         switch (MAPI_VERSION(*mapi_version))
 814         {
 815         case 1:
 816                 {
 817                         struct mapi_mheader_av1 *mheader = (struct mapi_mheader_av1 *) mapi_version;    /* see above */
 818                         if(mheader->mapi_register && (mheader->mapi_register() == -1))
 819                         {
 820                                 ilog(L_MAIN, "Module %s indicated failure during load.",
 821                                      mod_basename);
 822                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 823                                                      "Module %s indicated failure during load.",
 824                                                      mod_basename);
 825                                 dlclose(tmpptr);
 826                                 rb_free(mod_basename);
 827                                 return -1;
 828                         }
 829                         if(mheader->mapi_command_list)
 830                         {
 831                                 struct Message **m;
 832                                 for (m = mheader->mapi_command_list; *m; ++m)
 833                                         mod_add_cmd(*m);
 834                         }
 835
 836                         if(mheader->mapi_hook_list)
 837                         {
 838                                 mapi_hlist_av1 *m;
 839                                 for (m = mheader->mapi_hook_list; m->hapi_name; ++m)
 840                                         *m->hapi_id = register_hook(m->hapi_name);
 841                         }
 842
 843                         if(mheader->mapi_hfn_list)
 844                         {
 845                                 mapi_hfn_list_av1 *m;
 846                                 for (m = mheader->mapi_hfn_list; m->hapi_name; ++m)
 847                                         add_hook(m->hapi_name, m->fn);
 848                         }
 849
 850                         ver = mheader->mapi_module_version;
 851                         break;
 852                 }
 853
 854         default:
 855                 ilog(L_MAIN, "Module %s has unknown/unsupported MAPI version %d.",
 856                      mod_basename, MAPI_VERSION(*mapi_version));
 857                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 858                                      "Module %s has unknown/unsupported MAPI version %d.",
 859                                      mod_basename, *mapi_version);
 860                 dlclose(tmpptr);
 861                 rb_free(mod_basename);
 862                 return -1;
 863         }
 864
 865         if(ver == NULL)
 866                 ver = unknown_ver;
 867
 868         increase_modlist();
 869
 870         modlist[num_mods] = rb_malloc(sizeof(struct module));
 871         modlist[num_mods]->address = tmpptr;
 872         modlist[num_mods]->version = ver;
 873         modlist[num_mods]->core = core;
 874         modlist[num_mods]->name = rb_strdup(mod_basename);
 875         modlist[num_mods]->mapi_header = mapi_version;
 876         modlist[num_mods]->mapi_version = MAPI_VERSION(*mapi_version);
 877         num_mods++;
 878
 879         if(warn == 1)
 880         {
 881                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 882                                      "Module %s [version: %s; MAPI version: %d] loaded at 0x%lx",
 883                                      mod_basename, ver, MAPI_VERSION(*mapi_version),
 884                                      (unsigned long) tmpptr);
 885                 ilog(L_MAIN, "Module %s [version: %s; MAPI version: %d] loaded at 0x%lx",
 886                      mod_basename, ver, MAPI_VERSION(*mapi_version), (unsigned long) tmpptr);
 887         }
 888         rb_free(mod_basename);
 889         return 0;
 890 }
 891
 892 /*
 893  * increase_modlist
 894  *
 895  * inputs       - NONE
 896  * output       - NONE
 897  * side effects - expand the size of modlist if necessary
 898  */
 899 static void
 900 increase_modlist(void)
 901 {
 902         struct module **new_modlist = NULL;
 903
 904         if((num_mods + 1) < max_mods)
 905                 return;
 906
 907         new_modlist = (struct module **) rb_malloc(sizeof(struct module) *
 908                                                   (max_mods + MODS_INCREMENT));
 909         memcpy((void *) new_modlist, (void *) modlist, sizeof(struct module) * num_mods);
 910
 911         rb_free(modlist);
 912         modlist = new_modlist;
 913         max_mods += MODS_INCREMENT;
 914 }
 915
 916 #else /* STATIC_MODULES */
 917
 918 /* load_all_modules()
 919  *
 920  * input        -
 921  * output       -
 922  * side effects - all the msgtabs are added for static modules
 923  */
 924 void
 925 load_all_modules(int warn)
 926 {
 927         load_static_modules();
 928 }
 929
 930 #endif /* STATIC_MODULES */