anope- supernets anope source code & configuration |
git clone git://git.acid.vegas/anope.git |
Log | Files | Refs | Archive | README |
modules.h (46390B)
1 /* Modular support 2 * 3 * (C) 2003-2022 Anope Team 4 * Contact us at team@anope.org 5 * 6 * Please read COPYING and README for further details. 7 * 8 * Based on the original code of Epona by Lara. 9 * Based on the original code of Services by Andy Church. 10 */ 11 12 #include "serialize.h" 13 14 #ifndef MODULES_H 15 #define MODULES_H 16 17 #include "base.h" 18 #include "modes.h" 19 #include "timers.h" 20 #include "logger.h" 21 #include "extensible.h" 22 #include "version.h" 23 24 /** This definition is used as shorthand for the various classes 25 * and functions needed to make a module loadable by the OS. 26 * It defines the class factory and external AnopeInit and AnopeFini functions. 27 */ 28 #ifdef _WIN32 29 # define MODULE_INIT(x) \ 30 extern "C" DllExport Module *AnopeInit(const Anope::string &, const Anope::string &); \ 31 extern "C" Module *AnopeInit(const Anope::string &modname, const Anope::string &creator) \ 32 { \ 33 return new x(modname, creator); \ 34 } \ 35 BOOLEAN WINAPI DllMain(HINSTANCE, DWORD, LPVOID) \ 36 { \ 37 return TRUE; \ 38 } \ 39 extern "C" DllExport void AnopeFini(x *); \ 40 extern "C" void AnopeFini(x *m) \ 41 { \ 42 delete m; \ 43 } \ 44 extern "C" DllExport ModuleVersionC AnopeVersion() \ 45 { \ 46 ModuleVersionC ver; \ 47 ver.version_major = VERSION_MAJOR; \ 48 ver.version_minor = VERSION_MINOR; \ 49 ver.version_patch = VERSION_PATCH; \ 50 return ver; \ 51 } 52 #else 53 # define MODULE_INIT(x) \ 54 extern "C" DllExport Module *AnopeInit(const Anope::string &modname, const Anope::string &creator) \ 55 { \ 56 return new x(modname, creator); \ 57 } \ 58 extern "C" DllExport void AnopeFini(x *m) \ 59 { \ 60 delete m; \ 61 } \ 62 extern "C" DllExport ModuleVersionC AnopeVersion() \ 63 { \ 64 ModuleVersionC ver; \ 65 ver.version_major = VERSION_MAJOR; \ 66 ver.version_minor = VERSION_MINOR; \ 67 ver.version_patch = VERSION_PATCH; \ 68 return ver; \ 69 } 70 #endif 71 72 /** 73 * This #define allows us to call a method in all 74 * loaded modules in a readable simple way, e.g.: 75 * 76 * FOREACH_MOD(OnUserConnect, (user, exempt)); 77 */ 78 #define FOREACH_MOD(ename, args) \ 79 if (true) \ 80 { \ 81 std::vector<Module *> &_modules = ModuleManager::EventHandlers[I_ ## ename]; \ 82 for (std::vector<Module *>::iterator _i = _modules.begin(); _i != _modules.end();) \ 83 { \ 84 try \ 85 { \ 86 (*_i)->ename args; \ 87 } \ 88 catch (const ModuleException &modexcept) \ 89 { \ 90 Log() << "Exception caught: " << modexcept.GetReason(); \ 91 } \ 92 catch (const NotImplementedException &) \ 93 { \ 94 _i = _modules.erase(_i); \ 95 continue; \ 96 } \ 97 ++_i; \ 98 } \ 99 } \ 100 else \ 101 static_cast<void>(0) 102 103 /** 104 * This define is similar to the one above but returns a result. 105 * The first module to return a result other than EVENT_CONTINUE is the value to be accepted, 106 * and any modules after are ignored. This is used like: 107 * 108 * EventReturn MOD_RESULT; 109 * FOREACH_RESULT(OnUserConnect, MOD_RESULT, (user, exempt)); 110 */ 111 #define FOREACH_RESULT(ename, ret, args) \ 112 if (true) \ 113 { \ 114 ret = EVENT_CONTINUE; \ 115 std::vector<Module *> &_modules = ModuleManager::EventHandlers[I_ ## ename]; \ 116 for (std::vector<Module *>::iterator _i = _modules.begin(); _i != _modules.end();) \ 117 { \ 118 try \ 119 { \ 120 EventReturn res = (*_i)->ename args; \ 121 if (res != EVENT_CONTINUE) \ 122 { \ 123 ret = res; \ 124 break; \ 125 } \ 126 } \ 127 catch (const ModuleException &modexcept) \ 128 { \ 129 Log() << "Exception caught: " << modexcept.GetReason(); \ 130 } \ 131 catch (const NotImplementedException &) \ 132 { \ 133 _i = _modules.erase(_i); \ 134 continue; \ 135 } \ 136 ++_i; \ 137 } \ 138 } \ 139 else \ 140 static_cast<void>(0) 141 142 143 /** Possible return types from events. 144 */ 145 enum EventReturn 146 { 147 EVENT_STOP, 148 EVENT_CONTINUE, 149 EVENT_ALLOW 150 }; 151 152 enum ModuleReturn 153 { 154 MOD_ERR_OK, 155 MOD_ERR_PARAMS, 156 MOD_ERR_EXISTS, 157 MOD_ERR_NOEXIST, 158 MOD_ERR_NOLOAD, 159 MOD_ERR_UNKNOWN, 160 MOD_ERR_FILE_IO, 161 MOD_ERR_EXCEPTION, 162 MOD_ERR_VERSION 163 }; 164 165 /** Priority types which can be returned from Module::Prioritize() 166 */ 167 enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER }; 168 /* Module types, in the order in which they are unloaded. The order these are in is IMPORTANT */ 169 enum 170 { 171 MT_BEGIN, 172 /* Module is 3rd party. All 3rd party modules should set this. Mutually exclusive to VENDOR. */ 173 THIRD = 1 << 0, 174 /* A vendor module, which is made and shipped by Anope. Mutually exclusive to THIRD. */ 175 VENDOR = 1 << 1, 176 /* Extra module not required for standard use. Probably requires external dependencies. 177 * This module does something extreme enough that we want it to show in the default /os modlist command 178 */ 179 EXTRA = 1 << 2, 180 /* Module provides access to a database */ 181 DATABASE = 1 << 3, 182 /* Module provides encryption */ 183 ENCRYPTION = 1 << 4, 184 /* Module provides a pseudoclient */ 185 PSEUDOCLIENT = 1 << 5, 186 /* Module provides IRCd protocol support */ 187 PROTOCOL = 1 << 6, 188 MT_END = 1 << 7 189 }; 190 typedef unsigned short ModType; 191 192 struct ModuleVersionC 193 { 194 int version_major, version_minor, version_patch; 195 }; 196 197 /** Returned by Module::GetVersion, used to see what version of Anope 198 * a module is compiled against. 199 */ 200 class ModuleVersion 201 { 202 private: 203 int version_major; 204 int version_minor; 205 int version_patch; 206 207 public: 208 ModuleVersion(const ModuleVersionC &); 209 210 /** Get the major version of Anope this was built against 211 * @return The major version 212 */ 213 int GetMajor() const; 214 215 /** Get the minor version of Anope this was built against 216 * @return The minor version 217 */ 218 int GetMinor() const; 219 220 /** Get the patch version this was built against 221 * @return The patch version 222 */ 223 int GetPatch() const; 224 }; 225 226 class NotImplementedException : public CoreException { }; 227 228 /** Every module in Anope is actually a class. 229 */ 230 class CoreExport Module : public Extensible 231 { 232 private: 233 bool permanent; 234 public: 235 /** The module name (e.g. os_modload) 236 */ 237 Anope::string name; 238 239 /** What type this module is 240 */ 241 ModType type; 242 243 /** The temporary path/filename 244 */ 245 Anope::string filename; 246 247 /** Handle for this module, obtained from dlopen() 248 */ 249 void *handle; 250 251 /** Time this module was created 252 */ 253 time_t created; 254 255 /** Version of this module 256 */ 257 Anope::string version; 258 259 /** Author of the module 260 */ 261 Anope::string author; 262 263 /** Creates and initialises a new module. 264 * @param modname The module name 265 * @param loadernick The nickname of the user loading the module. 266 * @param type The module type 267 */ 268 Module(const Anope::string &modname, const Anope::string &loadernick, ModType type = THIRD); 269 270 /** Destroys a module, freeing resources it has allocated. 271 */ 272 virtual ~Module(); 273 274 /** Toggles the permanent flag on a module. If a module is permanent, 275 * then it may not be unloaded. 276 * 277 * Naturally, this setting should be used sparingly! 278 * 279 * @param state True if this module should be permanent, false else. 280 */ 281 void SetPermanent(bool state); 282 283 /** Retrieves whether or not a given module is permanent. 284 * @return true if the module is permanent, false else. 285 */ 286 bool GetPermanent() const; 287 288 /** Set the modules version info. 289 * @param version the version of the module 290 */ 291 void SetVersion(const Anope::string &version); 292 293 /** Set the modules author info 294 * @param author the author of the module 295 */ 296 void SetAuthor(const Anope::string &author); 297 298 virtual void Prioritize(); 299 300 /* Everything below here are events. Modules must ModuleManager::Attach to these events 301 * before they will be called. 302 */ 303 304 /** Called on startup after database load, but before 305 * connecting to the uplink. 306 */ 307 virtual void OnPostInit() { throw NotImplementedException(); } 308 309 /** Called before a user has been kicked from a channel. 310 * @param source The kicker 311 * @param cu The user, channel, and status of the user being kicked 312 * @param kickmsg The reason for the kick. 313 */ 314 virtual void OnPreUserKicked(const MessageSource &source, ChanUserContainer *cu, const Anope::string &kickmsg) { throw NotImplementedException(); } 315 316 /** Called when a user has been kicked from a channel. 317 * @param source The kicker 318 * @param target The user being kicked 319 * @param channel The channel the user was kicked from, which may no longer exist 320 * @param status The status the kicked user had on the channel before they were kicked 321 * @param kickmsg The reason for the kick. 322 */ 323 virtual void OnUserKicked(const MessageSource &source, User *target, const Anope::string &channel, ChannelStatus &status, const Anope::string &kickmsg) { throw NotImplementedException(); } 324 325 /** Called when Services' configuration is being (re)loaded. 326 * @param conf The config that is being built now and will replace the global Config object 327 * @throws A ConfigException to abort the config (re)loading process. 328 */ 329 virtual void OnReload(Configuration::Conf *conf) { throw NotImplementedException(); } 330 331 /** Called before a bot is assigned to a channel. 332 * @param sender The user assigning the bot 333 * @param ci The channel the bot is to be assigned to. 334 * @param bi The bot being assigned. 335 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the assign. 336 */ 337 virtual EventReturn OnPreBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) { throw NotImplementedException(); } 338 339 /** Called when a bot is assigned ot a channel 340 */ 341 virtual void OnBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) { throw NotImplementedException(); } 342 343 /** Called before a bot is unassigned from a channel. 344 * @param sender The user unassigning the bot 345 * @param ci The channel the bot is being removed from 346 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the unassign. 347 */ 348 virtual EventReturn OnBotUnAssign(User *sender, ChannelInfo *ci) { throw NotImplementedException(); } 349 350 /** Called when a new user connects to the network. 351 * @param u The connecting user. 352 * @param exempt set to true/is true if the user should be excepted from bans etc 353 */ 354 virtual void OnUserConnect(User *u, bool &exempt) { throw NotImplementedException(); } 355 356 /** Called when a new server connects to the network. 357 * @param s The server that has connected to the network 358 */ 359 virtual void OnNewServer(Server *s) { throw NotImplementedException(); } 360 361 /** Called after a user changed the nick 362 * @param u The user. 363 * @param oldnick The old nick of the user 364 */ 365 virtual void OnUserNickChange(User *u, const Anope::string &oldnick) { throw NotImplementedException(); } 366 367 /** Called when someone uses the generic/help command 368 * @param source Command source 369 * @param params Params 370 * @return EVENT_STOP to stop processing 371 */ 372 virtual EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 373 374 /** Called when someone uses the generic/help command 375 * @param source Command source 376 * @param params Params 377 */ 378 virtual void OnPostHelp(CommandSource &source, const std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 379 380 /** Called before a command is due to be executed. 381 * @param source The source of the command 382 * @param command The command the user is executing 383 * @param params The parameters the user is sending 384 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it 385 */ 386 virtual EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 387 388 /** Called after a command has been executed. 389 * @param source The source of the command 390 * @param command The command the user executed 391 * @param params The parameters the user sent 392 */ 393 virtual void OnPostCommand(CommandSource &source, Command *command, const std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 394 395 /** Called when the databases are saved 396 */ 397 virtual void OnSaveDatabase() { throw NotImplementedException(); } 398 399 /** Called when the databases are loaded 400 * @return EVENT_CONTINUE to let other modules continue loading, EVENT_STOP to stop 401 */ 402 virtual EventReturn OnLoadDatabase() { throw NotImplementedException(); } 403 404 /** Called when anope needs to check passwords against encryption 405 * see src/encrypt.c for detailed informations 406 */ 407 virtual EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest) { throw NotImplementedException(); } 408 virtual EventReturn OnDecrypt(const Anope::string &hashm, const Anope::string &src, Anope::string &dest) { throw NotImplementedException(); } 409 410 /** Called on fantasy command 411 * @param source The source of the command 412 * @param c The command 413 * @param ci The channel it's being used in 414 * @param params The params 415 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed 416 */ 417 virtual EventReturn OnBotFantasy(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 418 419 /** Called on fantasy command without access 420 * @param source The source of the command 421 * @param c The command 422 * @param ci The channel it's being used in 423 * @param params The params 424 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed 425 */ 426 virtual EventReturn OnBotNoFantasyAccess(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> ¶ms) { throw NotImplementedException(); } 427 428 /** Called when a bot places a ban 429 * @param u User being banned 430 * @param ci Channel the ban is placed on 431 * @param mask The mask being banned 432 */ 433 virtual void OnBotBan(User *u, ChannelInfo *ci, const Anope::string &mask) { throw NotImplementedException(); } 434 435 /** Called before a badword is added to the badword list 436 * @param ci The channel 437 * @param bw The badword 438 */ 439 virtual void OnBadWordAdd(ChannelInfo *ci, const BadWord *bw) { throw NotImplementedException(); } 440 441 /** Called before a badword is deleted from a channel 442 * @param ci The channel 443 * @param bw The badword 444 */ 445 virtual void OnBadWordDel(ChannelInfo *ci, const BadWord *bw) { throw NotImplementedException(); } 446 447 /** Called when a bot is created or destroyed 448 */ 449 virtual void OnCreateBot(BotInfo *bi) { throw NotImplementedException(); } 450 virtual void OnDelBot(BotInfo *bi) { throw NotImplementedException(); } 451 452 /** Called before a bot kicks a user 453 * @param bi The bot sending the kick 454 * @param c The channel the user is being kicked on 455 * @param u The user being kicked 456 * @param reason The reason 457 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it 458 */ 459 virtual EventReturn OnBotKick(BotInfo *bi, Channel *c, User *u, const Anope::string &reason) { throw NotImplementedException(); } 460 461 /** Called before a user parts a channel 462 * @param u The user 463 * @param c The channel 464 */ 465 virtual void OnPrePartChannel(User *u, Channel *c) {} 466 467 /** Called when a user parts a channel 468 * @param u The user 469 * @param c The channel, may be NULL if the channel no longer exists 470 * @param channel The channel name 471 * @param msg The part reason 472 */ 473 virtual void OnPartChannel(User *u, Channel *c, const Anope::string &channel, const Anope::string &msg) { throw NotImplementedException(); } 474 475 /** Called when a user leaves a channel. 476 * From either parting, being kicked, or quitting/killed! 477 * @param u The user 478 * @param c The channel 479 */ 480 virtual void OnLeaveChannel(User *u, Channel *c) { throw NotImplementedException(); } 481 482 /** Called after a user joins a channel 483 * If this event triggers the user is allowed to be in the channel, and will 484 * not be kicked for restricted/akick/forbidden, etc. If you want to kick the user, 485 * use the CheckKick event instead. 486 * @param u The user 487 * @param channel The channel 488 */ 489 virtual void OnJoinChannel(User *u, Channel *c) { throw NotImplementedException(); } 490 491 /** Called when a new topic is set 492 * @param source The user changing the topic, if any 493 * @param c The channel 494 * @param setter The user who set the new topic, if there is no source 495 * @param topic The new topic 496 */ 497 virtual void OnTopicUpdated(User *source, Channel *c, const Anope::string &user, const Anope::string &topic) { throw NotImplementedException(); } 498 499 /** Called before a channel expires 500 * @param ci The channel 501 * @param expire Set to true to allow the chan to expire 502 */ 503 virtual void OnPreChanExpire(ChannelInfo *ci, bool &expire) { throw NotImplementedException(); } 504 505 /** Called before a channel expires 506 * @param ci The channel 507 */ 508 virtual void OnChanExpire(ChannelInfo *ci) { throw NotImplementedException(); } 509 510 /** Called before Anope connects to its uplink 511 */ 512 virtual void OnPreServerConnect() { throw NotImplementedException(); } 513 514 /** Called when Anope connects to its uplink 515 */ 516 virtual void OnServerConnect() { throw NotImplementedException(); } 517 518 /** Called when we are almost done synching with the uplink, just before we send the EOB 519 */ 520 virtual void OnPreUplinkSync(Server *serv) { throw NotImplementedException(); } 521 522 /** Called when Anope disconnects from its uplink, before it tries to reconnect 523 */ 524 virtual void OnServerDisconnect() { throw NotImplementedException(); } 525 526 /** Called when services restart 527 */ 528 virtual void OnRestart() { throw NotImplementedException(); } 529 530 /** Called when services shutdown 531 */ 532 virtual void OnShutdown() { throw NotImplementedException(); } 533 534 /** Called before a nick expires 535 * @param na The nick 536 * @param expire Set to true to allow the nick to expire 537 */ 538 virtual void OnPreNickExpire(NickAlias *na, bool &expire) { throw NotImplementedException(); } 539 540 /** Called when a nick drops 541 * @param na The nick 542 */ 543 virtual void OnNickExpire(NickAlias *na) { throw NotImplementedException(); } 544 545 /** Called when defcon level changes 546 * @param level The level 547 */ 548 virtual void OnDefconLevel(int level) { throw NotImplementedException(); } 549 550 /** Called after an exception has been added 551 * @param ex The exception 552 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it 553 */ 554 virtual EventReturn OnExceptionAdd(Exception *ex) { throw NotImplementedException(); } 555 556 /** Called before an exception is deleted 557 * @param source The source deleting it 558 * @param ex The exception 559 */ 560 virtual void OnExceptionDel(CommandSource &source, Exception *ex) { throw NotImplementedException(); } 561 562 /** Called before a XLine is added 563 * @param source The source of the XLine 564 * @param x The XLine 565 * @param xlm The xline manager it was added to 566 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it 567 */ 568 virtual EventReturn OnAddXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { throw NotImplementedException(); } 569 570 /** Called before a XLine is deleted 571 * @param source The source of the XLine 572 * @param x The XLine 573 * @param xlm The xline manager it was deleted from 574 */ 575 virtual void OnDelXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { throw NotImplementedException(); } 576 577 /** Called when a user is checked for whether they are a services oper 578 * @param u The user 579 * @return EVENT_ALLOW to allow, anything else to deny 580 */ 581 virtual EventReturn IsServicesOper(User *u) { throw NotImplementedException(); } 582 583 /** Called when a server quits 584 * @param server The server 585 */ 586 virtual void OnServerQuit(Server *server) { throw NotImplementedException(); } 587 588 /** Called when a user quits, or is killed 589 * @param u The user 590 * @param msg The quit message 591 */ 592 virtual void OnUserQuit(User *u, const Anope::string &msg) { throw NotImplementedException(); } 593 594 /** Called when a user is quit, before and after being internally removed from 595 * This is different from OnUserQuit, which takes place at the time of the quit. 596 * This happens shortly after when all message processing is finished. 597 * all lists (channels, user list, etc) 598 * @param u The user 599 */ 600 virtual void OnPreUserLogoff(User *u) { throw NotImplementedException(); } 601 virtual void OnPostUserLogoff(User *u) { throw NotImplementedException(); } 602 603 /** Called when a new bot is made 604 * @param bi The bot 605 */ 606 virtual void OnBotCreate(BotInfo *bi) { throw NotImplementedException(); } 607 608 /** Called when a bot is changed 609 * @param bi The bot 610 */ 611 virtual void OnBotChange(BotInfo *bi) { throw NotImplementedException(); } 612 613 /** Called when a bot is deleted 614 * @param bi The bot 615 */ 616 virtual void OnBotDelete(BotInfo *bi) { throw NotImplementedException(); } 617 618 /** Called after an access entry is deleted from a channel 619 * @param ci The channel 620 * @param source The source of the command 621 * @param access The access entry that was removed 622 */ 623 virtual void OnAccessDel(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { throw NotImplementedException(); } 624 625 /** Called when access is added 626 * @param ci The channel 627 * @param source The source of the command 628 * @param access The access changed 629 */ 630 virtual void OnAccessAdd(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { throw NotImplementedException(); } 631 632 /** Called when the access list is cleared 633 * @param ci The channel 634 * @param u The user who cleared the access 635 */ 636 virtual void OnAccessClear(ChannelInfo *ci, CommandSource &source) { throw NotImplementedException(); } 637 638 /** Called when a level for a channel is changed 639 * @param source The source of the command 640 * @param ci The channel the level was changed on 641 * @param priv The privilege changed 642 * @param what The new level 643 */ 644 virtual void OnLevelChange(CommandSource &source, ChannelInfo *ci, const Anope::string &priv, int16_t what) { throw NotImplementedException(); } 645 646 /** Called right before a channel is dropped 647 * @param source The user dropping the channel 648 * @param ci The channel 649 */ 650 virtual EventReturn OnChanDrop(CommandSource &source, ChannelInfo *ci) { throw NotImplementedException(); } 651 652 /** Called when a channel is registered 653 * @param ci The channel 654 */ 655 virtual void OnChanRegistered(ChannelInfo *ci) { throw NotImplementedException(); } 656 657 /** Called when a channel is suspended 658 * @param ci The channel 659 */ 660 virtual void OnChanSuspend(ChannelInfo *ci) { throw NotImplementedException(); } 661 662 /** Called when a channel is unsuspended 663 * @param ci The channel 664 */ 665 virtual void OnChanUnsuspend(ChannelInfo *ci) { throw NotImplementedException(); } 666 667 /** Called when a channel is being created, for any reason 668 * @param ci The channel 669 */ 670 virtual void OnCreateChan(ChannelInfo *ci) { throw NotImplementedException(); } 671 672 /** Called when a channel is being deleted, for any reason 673 * @param ci The channel 674 */ 675 virtual void OnDelChan(ChannelInfo *ci) { throw NotImplementedException(); } 676 677 /** Called when a new channel is created 678 * Note that this channel may not be introduced to the uplink at this point. 679 * @param c The channel 680 */ 681 virtual void OnChannelCreate(Channel *c) { throw NotImplementedException(); } 682 683 /** Called when a channel is deleted 684 * @param c The channel 685 */ 686 virtual void OnChannelDelete(Channel *c) { throw NotImplementedException(); } 687 688 /** Called after adding an akick to a channel 689 * @param source The source of the command 690 * @param ci The channel 691 * @param ak The akick 692 */ 693 virtual void OnAkickAdd(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { throw NotImplementedException(); } 694 695 /** Called before removing an akick from a channel 696 * @param source The source of the command 697 * @param ci The channel 698 * @param ak The akick 699 */ 700 virtual void OnAkickDel(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { throw NotImplementedException(); } 701 702 /** Called after a user join a channel when we decide whether to kick them or not 703 * @param u The user 704 * @param c The channel 705 * @param kick Set to true to kick 706 * @param mask The mask to ban, if any 707 * @param reason The reason for the kick 708 * @return EVENT_STOP to prevent the user from joining by kicking/banning the user 709 */ 710 virtual EventReturn OnCheckKick(User *u, Channel *c, Anope::string &mask, Anope::string &reason) { throw NotImplementedException(); } 711 712 /** Called when a user requests info for a channel 713 * @param source The user requesting info 714 * @param ci The channel the user is requesting info for 715 * @param info Data to show the user requesting information 716 * @param show_hidden true if we should show the user everything 717 */ 718 virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool show_hidden) { throw NotImplementedException(); } 719 720 /** Checks if access has the channel privilege 'priv'. 721 * @param access THe access struct 722 * @param priv The privilege being checked for 723 * @return EVENT_ALLOW for yes, EVENT_STOP to stop all processing 724 */ 725 virtual EventReturn OnCheckPriv(const ChanAccess *access, const Anope::string &priv) { throw NotImplementedException(); } 726 727 /** Check whether an access group has a privilege 728 * @param group The group 729 * @param priv The privilege 730 * @return MOD_ALLOW to allow, MOD_STOP to stop 731 */ 732 virtual EventReturn OnGroupCheckPriv(const AccessGroup *group, const Anope::string &priv) { throw NotImplementedException(); } 733 734 /** Called when a nick is dropped 735 * @param source The source of the command 736 * @param na The nick 737 */ 738 virtual void OnNickDrop(CommandSource &source, NickAlias *na) { throw NotImplementedException(); } 739 740 /** Called when a user groups their nick 741 * @param u The user grouping 742 * @param target The target they're grouping to 743 */ 744 virtual void OnNickGroup(User *u, NickAlias *target) { throw NotImplementedException(); } 745 746 /** Called when a user identifies to a nick 747 * @param u The user 748 */ 749 virtual void OnNickIdentify(User *u) { throw NotImplementedException(); } 750 751 /** Called when a user is logged into an account 752 * @param u The user 753 */ 754 virtual void OnUserLogin(User *u) { throw NotImplementedException(); } 755 756 /** Called when a nick logs out 757 * @param u The nick 758 */ 759 virtual void OnNickLogout(User *u) { throw NotImplementedException(); } 760 761 /** Called when a nick is registered 762 * @param user The user registering the nick, of any 763 * @param The nick 764 * @param pass The password of the newly registered nick 765 */ 766 virtual void OnNickRegister(User *user, NickAlias *na, const Anope::string &pass) { throw NotImplementedException(); } 767 768 /** Called when a nick is confirmed. This will never be called if registration confirmation is not enabled. 769 * @param user The user confirming the nick 770 * @param The account being confirmed 771 */ 772 virtual void OnNickConfirm(User *user, NickCore *) { throw NotImplementedException(); } 773 774 /** Called when a nick is suspended 775 * @param na The nick alias 776 */ 777 virtual void OnNickSuspend(NickAlias *na) { throw NotImplementedException(); } 778 779 /** Called when a nick is unsuspended 780 * @param na The nick alias 781 */ 782 virtual void OnNickUnsuspended(NickAlias *na) { throw NotImplementedException(); } 783 784 /** Called on delnick() 785 * @ param na pointer to the nickalias 786 */ 787 virtual void OnDelNick(NickAlias *na) { throw NotImplementedException(); } 788 789 /** Called when a nickcore is created 790 * @param nc The nickcore 791 */ 792 virtual void OnNickCoreCreate(NickCore *nc) { throw NotImplementedException(); } 793 794 /** Called on delcore() 795 * @param nc pointer to the NickCore 796 */ 797 virtual void OnDelCore(NickCore *nc) { throw NotImplementedException(); } 798 799 /** Called on change_core_display() 800 * @param nc pointer to the NickCore 801 * @param newdisplay the new display 802 */ 803 virtual void OnChangeCoreDisplay(NickCore *nc, const Anope::string &newdisplay) { throw NotImplementedException(); } 804 805 /** called from NickCore::ClearAccess() 806 * @param nc pointer to the NickCore 807 */ 808 virtual void OnNickClearAccess(NickCore *nc) { throw NotImplementedException(); } 809 810 /** Called when a user adds an entry to their access list 811 * @param nc The nick 812 * @param entry The entry 813 */ 814 virtual void OnNickAddAccess(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); } 815 816 /** Called from NickCore::EraseAccess() 817 * @param nc pointer to the NickCore 818 * @param entry The access mask 819 */ 820 virtual void OnNickEraseAccess(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); } 821 822 /** called from NickCore::ClearCert() 823 * @param nc pointer to the NickCore 824 */ 825 virtual void OnNickClearCert(NickCore *nc) { throw NotImplementedException(); } 826 827 /** Called when a user adds an entry to their cert list 828 * @param nc The nick 829 * @param entry The entry 830 */ 831 virtual void OnNickAddCert(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); } 832 833 /** Called from NickCore::EraseCert() 834 * @param nc pointer to the NickCore 835 * @param entry The fingerprint 836 */ 837 virtual void OnNickEraseCert(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); } 838 839 /** Called when a user requests info for a nick 840 * @param source The user requesting info 841 * @param na The nick the user is requesting info from 842 * @param info Data to show the user requesting information 843 * @param show_hidden true if we should show the user everything 844 */ 845 virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool show_hidden) { throw NotImplementedException(); } 846 847 /** Called when a user uses botserv/info on a bot or channel. 848 */ 849 virtual void OnBotInfo(CommandSource &source, BotInfo *bi, ChannelInfo *ci, InfoFormatter &info) { throw NotImplementedException(); } 850 851 /** Check whether a username and password is correct 852 * @param u The user trying to identify, if applicable. 853 * @param req The login request 854 */ 855 virtual void OnCheckAuthentication(User *u, IdentifyRequest *req) { throw NotImplementedException(); } 856 857 /** Called when a user does /ns update 858 * @param u The user 859 */ 860 virtual void OnNickUpdate(User *u) { throw NotImplementedException(); } 861 862 /** Called when we get informed about a users SSL fingerprint 863 * when we call this, the fingerprint should already be stored in the user struct 864 * @param u pointer to the user 865 */ 866 virtual void OnFingerprint(User *u) { throw NotImplementedException(); } 867 868 /** Called when a user becomes (un)away 869 * @param message The message, is .empty() if unaway 870 */ 871 virtual void OnUserAway(User *u, const Anope::string &message) { throw NotImplementedException(); } 872 873 /** Called when a user invites one of our users to a channel 874 * @param source The user doing the inviting 875 * @param c The channel the user is inviting to 876 * @param targ The user being invited 877 */ 878 virtual void OnInvite(User *source, Channel *c, User *targ) { throw NotImplementedException(); } 879 880 /** Called when a vhost is deleted 881 * @param na The nickalias of the vhost 882 */ 883 virtual void OnDeleteVhost(NickAlias *na) { throw NotImplementedException(); } 884 885 /** Called when a vhost is set 886 * @param na The nickalias of the vhost 887 */ 888 virtual void OnSetVhost(NickAlias *na) { throw NotImplementedException(); } 889 890 /** Called when a users host changes 891 * @param u The user 892 */ 893 virtual void OnSetDisplayedHost(User *) { throw NotImplementedException(); } 894 895 /** Called when a memo is sent 896 * @param source The source of the memo 897 * @param target The target of the memo 898 * @param mi Memo info for target 899 * @param m The memo 900 */ 901 virtual void OnMemoSend(const Anope::string &source, const Anope::string &target, MemoInfo *mi, Memo *m) { throw NotImplementedException(); } 902 903 /** Called when a memo is deleted 904 * @param target The target the memo is being deleted from (nick or channel) 905 * @param mi The memo info 906 * @param m The memo 907 */ 908 virtual void OnMemoDel(const Anope::string &target, MemoInfo *mi, const Memo *m) { throw NotImplementedException(); } 909 910 /** Called when a mode is set on a channel 911 * @param c The channel 912 * @param setter The user or server that is setting the mode 913 * @param mode The mode 914 * @param param The mode param, if there is one 915 * @return EVENT_STOP to make mlock/secureops etc checks not happen 916 */ 917 virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string ¶m) { throw NotImplementedException(); } 918 919 /** Called when a mode is unset on a channel 920 * @param c The channel 921 * @param setter The user or server that is unsetting the mode 922 * @param mode The mode 923 * @param param The mode param, if there is one 924 * @return EVENT_STOP to make mlock/secureops etc checks not happen 925 */ 926 virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string ¶m) { throw NotImplementedException(); } 927 928 /** Called when a mode is set on a user 929 * @param setter who/what is setting the mode 930 * @param u The user 931 * @param mname The mode name 932 */ 933 virtual void OnUserModeSet(const MessageSource &setter, User *u, const Anope::string &mname) { throw NotImplementedException(); } 934 935 /** Called when a mode is unset from a user 936 * @param setter who/what is setting the mode 937 * @param u The user 938 * @param mname The mode name 939 */ 940 virtual void OnUserModeUnset(const MessageSource &setter, User *u, const Anope::string &mname) { throw NotImplementedException(); } 941 942 /** Called when a channel mode is introduced into Anope 943 * @param cm The mode 944 */ 945 virtual void OnChannelModeAdd(ChannelMode *cm) { throw NotImplementedException(); } 946 947 /** Called when a user mode is introduced into Anope 948 * @param um The mode 949 */ 950 virtual void OnUserModeAdd(UserMode *um) { throw NotImplementedException(); } 951 952 /** Called when a mode is about to be mlocked 953 * @param ci The channel the mode is being locked on 954 * @param lock The mode lock 955 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock. 956 */ 957 virtual EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) { throw NotImplementedException(); } 958 959 /** Called when a mode is about to be unlocked 960 * @param ci The channel the mode is being unlocked from 961 * @param lock The mode lock 962 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock. 963 */ 964 virtual EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) { throw NotImplementedException(); } 965 966 /** Called after a module is loaded 967 * @param u The user loading the module, can be NULL 968 * @param m The module 969 */ 970 virtual void OnModuleLoad(User *u, Module *m) { throw NotImplementedException(); } 971 972 /** Called before a module is unloaded 973 * @param u The user, can be NULL 974 * @param m The module 975 */ 976 virtual void OnModuleUnload(User *u, Module *m) { throw NotImplementedException(); } 977 978 /** Called when a server is synced 979 * @param s The server, can be our uplink server 980 */ 981 virtual void OnServerSync(Server *s) { throw NotImplementedException(); } 982 983 /** Called when we sync with our uplink 984 * @param s Our uplink 985 */ 986 virtual void OnUplinkSync(Server *s) { throw NotImplementedException(); } 987 988 /** Called when we receive a PRIVMSG for one of our clients 989 * @param u The user sending the PRIVMSG 990 * @param bi The target of the PRIVMSG 991 * @param message The message 992 * @return EVENT_STOP to halt processing 993 */ 994 virtual EventReturn OnBotPrivmsg(User *u, BotInfo *bi, Anope::string &message) { throw NotImplementedException(); } 995 996 /** Called when we receive a NOTICE for one of our clients 997 * @param u The user sending the NOTICE 998 * @param bi The target of the NOTICE 999 * @param message The message 1000 */ 1001 virtual void OnBotNotice(User *u, BotInfo *bi, Anope::string &message) { throw NotImplementedException(); } 1002 1003 /** Called when we receive a PRIVMSG for a registered channel we are in 1004 * @param u The source of the message 1005 * @param c The channel 1006 * @param msg The message 1007 */ 1008 virtual void OnPrivmsg(User *u, Channel *c, Anope::string &msg) { throw NotImplementedException(); } 1009 1010 /** Called when a message is logged 1011 * @param l The log message 1012 */ 1013 virtual void OnLog(Log *l) { throw NotImplementedException(); } 1014 1015 /** Called when a log message is actually logged to a given log info 1016 * The message has already passed validation checks by the LogInfo 1017 * @param li The loginfo whee the message is being logged 1018 * @param l The log message 1019 * @param msg The final formatted message, derived from 'l' 1020 */ 1021 virtual void OnLogMessage(LogInfo *li, const Log *l, const Anope::string &msg) { throw NotImplementedException(); } 1022 1023 /** Called when a DNS request (question) is received. 1024 * @param req The dns request 1025 * @param reply The reply that will be sent 1026 */ 1027 virtual void OnDnsRequest(DNS::Query &req, DNS::Query *reply) { throw NotImplementedException(); } 1028 1029 /** Called when a channels modes are being checked to see if they are allowed, 1030 * mostly to ensure mlock/+r are set. 1031 * @param c The channel 1032 */ 1033 virtual void OnCheckModes(Reference<Channel> &c) { throw NotImplementedException(); } 1034 1035 /** Called when a channel is synced. 1036 * Channels are synced after a sjoin is finished processing 1037 * for a newly created channel to set the correct modes, topic, 1038 * set. 1039 */ 1040 virtual void OnChannelSync(Channel *c) { throw NotImplementedException(); } 1041 1042 /** Called to set the correct modes on the user on the given channel 1043 * @param user The user 1044 * @param chan The channel 1045 * @param access The user's access on the channel 1046 * @param give_modes If giving modes is desired 1047 * @param take_modes If taking modes is desired 1048 */ 1049 virtual void OnSetCorrectModes(User *user, Channel *chan, AccessGroup &access, bool &give_modes, bool &take_modes) { throw NotImplementedException(); } 1050 1051 virtual void OnSerializeCheck(Serialize::Type *) { throw NotImplementedException(); } 1052 virtual void OnSerializableConstruct(Serializable *) { throw NotImplementedException(); } 1053 virtual void OnSerializableDestruct(Serializable *) { throw NotImplementedException(); } 1054 virtual void OnSerializableUpdate(Serializable *) { throw NotImplementedException(); } 1055 virtual void OnSerializeTypeCreate(Serialize::Type *) { throw NotImplementedException(); } 1056 1057 /** Called when a chanserv/set command is used 1058 * @param source The source of the command 1059 * @param cmd The command 1060 * @param ci The channel the command was used on 1061 * @param setting The setting passed to the command. Probably ON/OFF. 1062 * @return EVENT_ALLOW to bypass access checks, EVENT_STOP to halt immediately. 1063 */ 1064 virtual EventReturn OnSetChannelOption(CommandSource &source, Command *cmd, ChannelInfo *ci, const Anope::string &setting) { throw NotImplementedException(); } 1065 1066 /** Called when a nickserv/set command is used. 1067 * @param source The source of the command 1068 * @param cmd The command 1069 * @param nc The nickcore being modifed 1070 * @param setting The setting passed to the command. Probably ON/OFF. 1071 * @return EVENT_STOP to halt immediately 1072 */ 1073 virtual EventReturn OnSetNickOption(CommandSource &source, Command *cmd, NickCore *nc, const Anope::string &setting) { throw NotImplementedException(); } 1074 1075 /** Called whenever a message is received from the uplink 1076 * @param source The source of the message 1077 * @param command The command being executed 1078 * @param params Parameters 1079 * @return EVENT_STOP to prevent the protocol module from processing this message 1080 */ 1081 virtual EventReturn OnMessage(MessageSource &source, Anope::string &command, std::vector<Anope::string> ¶m) { throw NotImplementedException(); } 1082 1083 /** Called to determine if a channel mode can be set by a user 1084 * @param u The user 1085 * @param cm The mode 1086 */ 1087 virtual EventReturn OnCanSet(User *u, const ChannelMode *cm) { throw NotImplementedException(); } 1088 1089 virtual EventReturn OnCheckDelete(Channel *) { throw NotImplementedException(); } 1090 1091 /** Called every options:expiretimeout seconds. Should be used to expire nicks, 1092 * channels, etc. 1093 */ 1094 virtual void OnExpireTick() { throw NotImplementedException(); } 1095 1096 /** Called when a nick is validated. That is, to determine if a user is permitted 1097 * to be on the given nick. 1098 * @param u The user 1099 * @param na The nick they are on 1100 * @return EVENT_STOP to force the user off of the nick 1101 */ 1102 virtual EventReturn OnNickValidate(User *u, NickAlias *na) { throw NotImplementedException(); } 1103 1104 /** Called when a certain user has to be unbanned on a certain channel. 1105 * May be used to send protocol-specific messages. 1106 * @param u The user to be unbanned 1107 * @param c The channel that user has to be unbanned on 1108 */ 1109 virtual void OnChannelUnban(User *u, ChannelInfo *ci) { throw NotImplementedException(); } 1110 }; 1111 1112 enum Implementation 1113 { 1114 I_OnPostInit, 1115 I_OnPreUserKicked, I_OnUserKicked, I_OnReload, I_OnPreBotAssign, I_OnBotAssign, I_OnBotUnAssign, I_OnUserConnect, 1116 I_OnNewServer, I_OnUserNickChange, I_OnPreHelp, I_OnPostHelp, I_OnPreCommand, I_OnPostCommand, I_OnSaveDatabase, 1117 I_OnLoadDatabase, I_OnEncrypt, I_OnDecrypt, I_OnBotFantasy, I_OnBotNoFantasyAccess, I_OnBotBan, I_OnBadWordAdd, 1118 I_OnBadWordDel, I_OnCreateBot, I_OnDelBot, I_OnBotKick, I_OnPrePartChannel, I_OnPartChannel, I_OnLeaveChannel, 1119 I_OnJoinChannel, I_OnTopicUpdated, I_OnPreChanExpire, I_OnChanExpire, I_OnPreServerConnect, I_OnServerConnect, 1120 I_OnPreUplinkSync, I_OnServerDisconnect, I_OnRestart, I_OnShutdown, I_OnPreNickExpire, I_OnNickExpire, I_OnDefconLevel, 1121 I_OnExceptionAdd, I_OnExceptionDel, I_OnAddXLine, I_OnDelXLine, I_IsServicesOper, I_OnServerQuit, I_OnUserQuit, 1122 I_OnPreUserLogoff, I_OnPostUserLogoff, I_OnBotCreate, I_OnBotChange, I_OnBotDelete, I_OnAccessDel, I_OnAccessAdd, 1123 I_OnAccessClear, I_OnLevelChange, I_OnChanDrop, I_OnChanRegistered, I_OnChanSuspend, I_OnChanUnsuspend, 1124 I_OnCreateChan, I_OnDelChan, I_OnChannelCreate, I_OnChannelDelete, I_OnAkickAdd, I_OnAkickDel, I_OnCheckKick, 1125 I_OnChanInfo, I_OnCheckPriv, I_OnGroupCheckPriv, I_OnNickDrop, I_OnNickGroup, I_OnNickIdentify, 1126 I_OnUserLogin, I_OnNickLogout, I_OnNickRegister, I_OnNickConfirm, I_OnNickSuspend, I_OnNickUnsuspended, I_OnDelNick, I_OnNickCoreCreate, 1127 I_OnDelCore, I_OnChangeCoreDisplay, I_OnNickClearAccess, I_OnNickAddAccess, I_OnNickEraseAccess, I_OnNickClearCert, 1128 I_OnNickAddCert, I_OnNickEraseCert, I_OnNickInfo, I_OnBotInfo, I_OnCheckAuthentication, I_OnNickUpdate, 1129 I_OnFingerprint, I_OnUserAway, I_OnInvite, I_OnDeleteVhost, I_OnSetVhost, I_OnSetDisplayedHost, I_OnMemoSend, I_OnMemoDel, 1130 I_OnChannelModeSet, I_OnChannelModeUnset, I_OnUserModeSet, I_OnUserModeUnset, I_OnChannelModeAdd, I_OnUserModeAdd, 1131 I_OnMLock, I_OnUnMLock, I_OnModuleLoad, I_OnModuleUnload, I_OnServerSync, I_OnUplinkSync, I_OnBotPrivmsg, I_OnBotNotice, 1132 I_OnPrivmsg, I_OnLog, I_OnLogMessage, I_OnDnsRequest, I_OnCheckModes, I_OnChannelSync, I_OnSetCorrectModes, 1133 I_OnSerializeCheck, I_OnSerializableConstruct, I_OnSerializableDestruct, I_OnSerializableUpdate, 1134 I_OnSerializeTypeCreate, I_OnSetChannelOption, I_OnSetNickOption, I_OnMessage, I_OnCanSet, I_OnCheckDelete, 1135 I_OnExpireTick, I_OnNickValidate, I_OnChannelUnban, 1136 I_SIZE 1137 }; 1138 1139 /** Used to manage modules. 1140 */ 1141 class CoreExport ModuleManager 1142 { 1143 public: 1144 /** Event handler hooks. 1145 */ 1146 static std::vector<Module *> EventHandlers[I_SIZE]; 1147 1148 /** List of all modules loaded in Anope 1149 */ 1150 static std::list<Module *> Modules; 1151 1152 #ifdef _WIN32 1153 /** Clean up the module runtime directory 1154 */ 1155 static void CleanupRuntimeDirectory(); 1156 #endif 1157 1158 /** Loads a given module. 1159 * @param m the module to load 1160 * @param u the user who loaded it, NULL for auto-load 1161 * @return MOD_ERR_OK on success, anything else on fail 1162 */ 1163 static ModuleReturn LoadModule(const Anope::string &modname, User *u); 1164 1165 /** Unload the given module. 1166 * @param m the module to unload 1167 * @param u the user who unloaded it 1168 * @return MOD_ERR_OK on success, anything else on fail 1169 */ 1170 static ModuleReturn UnloadModule(Module *m, User * u); 1171 1172 /** Find a module 1173 * @param name The module name 1174 * @return The module 1175 */ 1176 static Module *FindModule(const Anope::string &name); 1177 1178 /** Find the first module of a certain type 1179 * @param type The module type 1180 * @return The module 1181 */ 1182 static Module *FindFirstOf(ModType type); 1183 1184 /** Checks whether this version of Anope is at least major.minor.patch.build 1185 * Throws a ModuleException if not 1186 * @param major The major version 1187 * @param minor The minor version 1188 * @param patch The patch version 1189 */ 1190 static void RequireVersion(int major, int minor, int patch); 1191 1192 /** Change the priority of one event in a module. 1193 * Each module event has a list of modules which are attached to that event type. If you wish to be called before or after other specific modules, you may use this 1194 * method (usually within void Module::Prioritize()) to set your events priority. You may use this call in other methods too, however, this is not supported behaviour 1195 * for a module. 1196 * @param mod The module to change the priority of 1197 * @param i The event to change the priority of 1198 * @param s The state you wish to use for this event. Use one of 1199 * PRIO_FIRST to set the event to be first called, PRIO_LAST to set it to be the last called, or PRIO_BEFORE and PRIO_AFTER 1200 * to set it to be before or after one or more other modules. 1201 * @param modules If PRIO_BEFORE or PRIO_AFTER is set in parameter 's', then this contains a list of one or more modules your module must be 1202 * placed before or after. Your module will be placed before the highest priority module in this list for PRIO_BEFORE, or after the lowest 1203 * priority module in this list for PRIO_AFTER. 1204 * @param sz The number of modules being passed for PRIO_BEFORE and PRIO_AFTER. Defaults to 1, as most of the time you will only want to prioritize your module 1205 * to be before or after one other module. 1206 */ 1207 static bool SetPriority(Module *mod, Implementation i, Priority s, Module **modules = NULL, size_t sz = 1); 1208 1209 /** Change the priority of all events in a module. 1210 * @param mod The module to set the priority of 1211 * @param s The priority of all events in the module. 1212 * Note that with this method, it is not possible to effectively use PRIO_BEFORE or PRIO_AFTER, you should use the more fine tuned 1213 * SetPriority method for this, where you may specify other modules to be prioritized against. 1214 */ 1215 static bool SetPriority(Module *mod, Priority s); 1216 1217 /** Detach all events from a module (used on unload) 1218 * @param mod Module to detach from 1219 */ 1220 static void DetachAll(Module *mod); 1221 1222 /** Unloading all modules except the protocol module. 1223 */ 1224 static void UnloadAll(); 1225 1226 private: 1227 /** Call the module_delete function to safely delete the module 1228 * @param m the module to delete 1229 * @return MOD_ERR_OK on success, anything else on fail 1230 */ 1231 static ModuleReturn DeleteModule(Module *m); 1232 1233 /** Get the version of Anope the module was compiled against 1234 * @return The version 1235 */ 1236 static ModuleVersion GetVersion(void *handle); 1237 }; 1238 1239 #endif // MODULES_H