modules.h

Go to the documentation of this file.

/* Modular support
 *
 * (C) 2003-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */

#include "serialize.h"

#ifndef MODULES_H
#define MODULES_H

#include "base.h"
#include "modes.h"
#include "timers.h"
#include "logger.h"
#include "extensible.h"

#ifdef _WIN32
# define MODULE_INIT(x) \
        extern "C" DllExport Module *AnopeInit(const Anope::string &, const Anope::string &); \
        extern "C" Module *AnopeInit(const Anope::string &modname, const Anope::string &creator) \
        { \
                return new x(modname, creator); \
        } \
        BOOLEAN WINAPI DllMain(HINSTANCE, DWORD, LPVOID) \
        { \
                return TRUE; \
        } \
        extern "C" DllExport void AnopeFini(x *); \
        extern "C" void AnopeFini(x *m) \
        { \
                delete m; \
        }
#else
# define MODULE_INIT(x) \
        extern "C" DllExport Module *AnopeInit(const Anope::string &modname, const Anope::string &creator) \
        { \
                return new x(modname, creator); \
        } \
        extern "C" DllExport void AnopeFini(x *m) \
        { \
                delete m; \
        }
#endif

#define FOREACH_MOD(y, x) \
if (true) \
{ \
        std::vector<Module *>::iterator safei; \
        for (std::vector<Module *>::iterator _i = ModuleManager::EventHandlers[y].begin(); _i != ModuleManager::EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        (*_i)->x ; \
                } \
                catch (const ModuleException &modexcept) \
                { \
                        Log() << "Exception caught: " << modexcept.GetReason(); \
                } \
                _i = safei; \
        } \
} \
else \
        static_cast<void>(0)

#define FOREACH_RESULT(y, x) \
if (true) \
{ \
        std::vector<Module *>::iterator safei; \
        MOD_RESULT = EVENT_CONTINUE; \
        for (std::vector<Module *>::iterator _i = ModuleManager::EventHandlers[y].begin(); _i != ModuleManager::EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        EventReturn res = (*_i)->x ; \
                        if (res != EVENT_CONTINUE) { \
                                MOD_RESULT = res; \
                                break; \
                        } \
                } \
                catch (const ModuleException &modexcept) \
                { \
                        Log() << "Exception caught: " << modexcept.GetReason(); \
                } \
                _i = safei; \
        } \
} \
else \
        static_cast<void>(0)

enum EventReturn
{
        EVENT_STOP,
        EVENT_CONTINUE,
        EVENT_ALLOW
};

enum ModuleReturn
{
        MOD_ERR_OK,
        MOD_ERR_MEMORY,
        MOD_ERR_PARAMS,
        MOD_ERR_EXISTS,
        MOD_ERR_NOEXIST,
        MOD_ERR_NOLOAD,
        MOD_ERR_UNKNOWN,
        MOD_ERR_FILE_IO,
        MOD_ERR_EXCEPTION,
        MOD_ERR_VERSION
};

enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
/* Module types, in the order in which they are unloaded. The order these are in is IMPORTANT */
enum ModType { MT_BEGIN, THIRD, SUPPORTED, CORE, DATABASE, ENCRYPTION, PROTOCOL, MT_END };

class ModuleVersion
{
 private:
        int version_major;
        int version_minor;
        int version_patch;

 public:
        ModuleVersion(int major, int minor, int patch);

        int GetMajor() const;

        int GetMinor() const;

        int GetPatch() const;
};


class CoreExport Module : public Extensible
{
 private:
        bool permanent;
 public:
        Anope::string name;

        ModType type;

        Anope::string filename;

        std::list<CallBack *> callbacks;

        void *handle;

        time_t created;

        Anope::string version;

        Anope::string author;

        Module(const Anope::string &modname, const Anope::string &loadernick, ModType type = THIRD);

        virtual ~Module();

        void SetPermanent(bool state);

        bool GetPermanent() const;

        void SetVersion(const Anope::string &version);

        void SetAuthor(const Anope::string &author);

        ModuleVersion GetVersion() const;

        /* Everything below here are events. Modules must ModuleManager::Attach to these events
         * before they will be called.
         */

        virtual void OnUserKicked(Channel *c, User *target, MessageSource &source, const Anope::string &kickmsg) { }

        virtual void OnReload() { }

        virtual EventReturn OnBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) { return EVENT_CONTINUE; }

        virtual EventReturn OnBotUnAssign(User *sender, ChannelInfo *ci) { return EVENT_CONTINUE; }

        virtual void OnUserConnect(User *u, bool &exempt) { }

        virtual void OnNewServer(Server *s) { }

        virtual void OnUserNickChange(User *u, const Anope::string &oldnick) { }

        virtual EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> &params) { return EVENT_CONTINUE; }

        virtual void OnPostHelp(CommandSource &source, const std::vector<Anope::string> &params) { }

        virtual EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> &params) { return EVENT_CONTINUE; }

        virtual void OnPostCommand(CommandSource &source, Command *command, const std::vector<Anope::string> &params) { }

        virtual EventReturn OnSaveDatabase() { return EVENT_CONTINUE; }

        virtual EventReturn OnLoadDatabase() { return EVENT_CONTINUE; }

        virtual EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest) { return EVENT_CONTINUE; }
        virtual EventReturn OnDecrypt(const Anope::string &hashm, const Anope::string &src, Anope::string &dest) { return EVENT_CONTINUE; }

        virtual EventReturn OnBotFantasy(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) { return EVENT_CONTINUE; }

        virtual EventReturn OnBotNoFantasyAccess(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) { return EVENT_CONTINUE; }

        virtual void OnBotJoin(Channel *c, BotInfo *bi) { }

        virtual void OnBotBan(User *u, ChannelInfo *ci, const Anope::string &mask) { }

        virtual void OnBadWordAdd(ChannelInfo *ci, const BadWord *bw) { }

        virtual void OnBadWordDel(ChannelInfo *ci, const BadWord *bw) { }

        virtual EventReturn OnBotKick(BotInfo *bi, Channel *c, User *u, const Anope::string &reason) { return EVENT_CONTINUE; }

        virtual void OnPrePartChannel(User *u, Channel *c) {}

        virtual void OnPartChannel(User *u, Channel *c, const Anope::string &channel, const Anope::string &msg) { }

        virtual void OnLeaveChannel(User *u, Channel *c) { }

        virtual EventReturn OnPreJoinChannel(User *u, Channel *c) { return EVENT_CONTINUE; }

        virtual void OnJoinChannel(User *u, Channel *c) { }

        virtual void OnTopicUpdated(Channel *c, const Anope::string &user, const Anope::string &topic) { }

        virtual void OnPreChanExpire(ChannelInfo *ci, bool &expire) { }

        virtual void OnChanExpire(ChannelInfo *ci) { }

        virtual void OnPreServerConnect() { }

        virtual void OnServerConnect() { }

        virtual void OnPreUplinkSync(Server *serv) { }

        virtual void OnServerDisconnect() { }

        virtual void OnRestart() { }

        virtual void OnShutdown() { }

        virtual void OnPreNickExpire(NickAlias *na, bool &expire) { }

        virtual void OnNickExpire(NickAlias *na) { }

        virtual void OnDefconLevel(int level) { }

        virtual EventReturn OnExceptionAdd(Exception *ex) { return EVENT_CONTINUE; }

        virtual void OnExceptionDel(CommandSource &source, Exception *ex) { }

        virtual EventReturn OnAddXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { return EVENT_CONTINUE; }

        virtual void OnDelXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { }

        virtual EventReturn IsServicesOper(User *u) { return EVENT_CONTINUE; }

        virtual void OnServerQuit(Server *server) { }

        virtual void OnUserQuit(User *u, const Anope::string &msg) { }

        virtual void OnPreUserLogoff(User *u) { }
        virtual void OnPostUserLogoff(User *u) { }

        virtual void OnBotCreate(BotInfo *bi) { }

        virtual void OnBotChange(BotInfo *bi) { }

        virtual void OnBotDelete(BotInfo *bi) { }

        virtual void OnAccessDel(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { }

        virtual void OnAccessAdd(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { }

        virtual void OnAccessClear(ChannelInfo *ci, CommandSource &source) { }

        virtual void OnLevelChange(CommandSource &source, ChannelInfo *ci, const Anope::string &priv, int16_t what) { }

        virtual void OnChanDrop(ChannelInfo *ci) { }

        virtual void OnChanRegistered(ChannelInfo *ci) { }

        virtual void OnChanSuspend(ChannelInfo *ci) { }

        virtual void OnChanUnsuspend(ChannelInfo *ci) { }

        virtual void OnCreateChan(ChannelInfo *ci) { }

        virtual void OnDelChan(ChannelInfo *ci) { }

        virtual void OnChannelCreate(Channel *c) { }

        virtual void OnChannelDelete(Channel *c) { }

        virtual void OnAkickAdd(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { }

        virtual void OnAkickDel(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { }

        virtual EventReturn OnCheckKick(User *u, ChannelInfo *ci, Anope::string &mask, Anope::string &reason) { return EVENT_CONTINUE; }

        virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool show_hidden) { }

        virtual EventReturn OnCheckPriv(ChanAccess *access, const Anope::string &priv) { return EVENT_CONTINUE; }

        virtual EventReturn OnGroupCheckPriv(const AccessGroup *group, const Anope::string &priv) { return EVENT_CONTINUE; }

        virtual void OnNickDrop(CommandSource &source, NickAlias *na) { }

        virtual void OnNickForbidden(NickAlias *na) { }

        virtual void OnNickGroup(User *u, NickAlias *target) { }

        virtual void OnNickIdentify(User *u) { }

        virtual void OnNickLogout(User *u) { }

        virtual void OnNickRegister(NickAlias *na) { }

        virtual void OnNickSuspend(NickAlias *na) { }

        virtual void OnNickUnsuspended(NickAlias *na) { }

        virtual void OnDelNick(NickAlias *na) { }

        virtual void OnDelCore(NickCore *nc) { }

        virtual void OnChangeCoreDisplay(NickCore *nc, const Anope::string &newdisplay) { }

        virtual void OnNickClearAccess(NickCore *nc) { }

        virtual void OnNickAddAccess(NickCore *nc, const Anope::string &entry) { }

        virtual void OnNickEraseAccess(NickCore *nc, const Anope::string &entry) { }

        virtual void OnNickClearCert(NickCore *nc) { }

        virtual void OnNickAddCert(NickCore *nc, const Anope::string &entry) { }

        virtual void OnNickEraseCert(NickCore *nc, const Anope::string &entry) { }

        virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool show_hidden) { }

        virtual void OnCheckAuthentication(User *u, IdentifyRequest *req) { }

        virtual void OnNickUpdate(User *u) { }

        virtual void OnFingerprint(User *u) { }

        virtual void OnUserAway(User *u, const Anope::string &message) { }

        virtual void OnDeleteVhost(NickAlias *na) { }

        virtual void OnSetVhost(NickAlias *na) { }

        virtual void OnMemoSend(const Anope::string &source, const Anope::string &target, MemoInfo *mi, Memo *m) { }

        virtual void OnMemoDel(NickCore *nc, MemoInfo *mi, const Memo *m) { }

        virtual void OnMemoDel(ChannelInfo *ci, MemoInfo *mi, const Memo *m) { }

        virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, const Anope::string &mname, const Anope::string &param) { return EVENT_CONTINUE; }

        virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, const Anope::string &mname, const Anope::string &param) { return EVENT_CONTINUE; }

        virtual void OnUserModeSet(User *u, const Anope::string &mname) { }

        virtual void OnUserModeUnset(User *u, const Anope::string &mname) { }

        virtual void OnChannelModeAdd(ChannelMode *cm) { }

        virtual void OnUserModeAdd(UserMode *um) { }

        virtual EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) { return EVENT_CONTINUE; }

        virtual EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) { return EVENT_CONTINUE; }

        virtual void OnModuleLoad(User *u, Module *m) { }

        virtual void OnModuleUnload(User *u, Module *m) { }

        virtual void OnServerSync(Server *s) { }

        virtual void OnUplinkSync(Server *s) { }

        virtual EventReturn OnBotPrivmsg(User *u, BotInfo *bi, Anope::string &message) { return EVENT_CONTINUE; }

        virtual void OnPrivmsg(User *u, Channel *c, Anope::string &msg) { }

        virtual void OnLog(Log *l) { }

        virtual void OnDnsRequest(DNS::Packet &req, DNS::Packet *reply) { }

        virtual EventReturn OnCheckModes(Channel *c) { return EVENT_CONTINUE; }

        virtual void OnSerializeCheck(Serialize::Type *) { }
        virtual void OnSerializableConstruct(Serializable *) { }
        virtual void OnSerializableDestruct(Serializable *) { }
        virtual void OnSerializableUpdate(Serializable *) { }
        virtual void OnSerializeTypeCreate(Serialize::Type *) { }

        virtual EventReturn OnSetChannelOption(CommandSource &source, Command *cmd, ChannelInfo *ci, const Anope::string &setting) { return EVENT_CONTINUE; }

        virtual EventReturn OnSetNickOption(CommandSource &source, Command *cmd, NickCore *nc, const Anope::string &setting) { return EVENT_CONTINUE; }

        virtual EventReturn OnMessage(MessageSource &source, Anope::string &command, std::vector<Anope::string> &param) { return EVENT_CONTINUE; }
};

enum Implementation
{
        I_BEGIN,
                /* NickServ */
                I_OnPreNickExpire, I_OnNickExpire, I_OnNickForbidden, I_OnNickGroup, I_OnNickLogout, I_OnNickIdentify, I_OnNickDrop,
                I_OnNickRegister, I_OnNickSuspended, I_OnNickUnsuspended, I_OnDelNick, I_OnDelCore, I_OnChangeCoreDisplay,
                I_OnNickClearAccess, I_OnNickAddAccess, I_OnNickEraseAccess, I_OnNickClearCert, I_OnNickAddCert, I_OnNickEraseCert,
                I_OnNickInfo, I_OnCheckAuthentication, I_OnNickUpdate, I_OnSetNickOption,

                /* ChanServ */
                I_OnChanSuspend, I_OnChanDrop, I_OnPreChanExpire, I_OnChanExpire, I_OnAccessAdd,
                I_OnAccessDel, I_OnAccessClear, I_OnLevelChange, I_OnChanRegistered, I_OnChanUnsuspend, I_OnCreateChan, I_OnDelChan, I_OnChannelCreate,
                I_OnChannelDelete, I_OnAkickAdd, I_OnAkickDel, I_OnCheckKick, I_OnCheckModes,
                I_OnChanInfo, I_OnCheckPriv, I_OnGroupCheckPriv, I_OnSetChannelOption,

                /* BotServ */
                I_OnBotJoin, I_OnBotKick, I_OnBotCreate, I_OnBotChange, I_OnBotDelete, I_OnBotAssign, I_OnBotUnAssign,
                I_OnUserKicked, I_OnBotFantasy, I_OnBotNoFantasyAccess, I_OnBotBan, I_OnBadWordAdd, I_OnBadWordDel,

                /* HostServ */
                I_OnSetVhost, I_OnDeleteVhost,

                /* MemoServ */
                I_OnMemoSend, I_OnMemoDel,

                /* Users */
                I_OnUserConnect, I_OnUserNickChange, I_OnUserQuit, I_OnPreUserLogoff, I_OnPostUserLogoff, I_OnPreJoinChannel,
                I_OnJoinChannel, I_OnPrePartChannel, I_OnPartChannel, I_OnLeaveChannel, I_OnFingerprint, I_OnUserAway,

                /* OperServ */
                I_OnDefconLevel, I_OnAddAkill, I_OnDelAkill, I_OnExceptionAdd, I_OnExceptionDel,
                I_OnAddXLine, I_OnDelXLine, I_IsServicesOper,

                /* Database */
                I_OnSaveDatabase, I_OnLoadDatabase,

                /* Modules */
                I_OnModuleLoad, I_OnModuleUnload,

                /* Other */
                I_OnReload, I_OnNewServer, I_OnPreServerConnect, I_OnServerConnect, I_OnPreUplinkSync, I_OnServerDisconnect,
                I_OnPreHelp, I_OnPostHelp, I_OnPreCommand, I_OnPostCommand, I_OnRestart, I_OnShutdown,
                I_OnServerQuit, I_OnTopicUpdated,
                I_OnEncrypt, I_OnDecrypt,
                I_OnChannelModeSet, I_OnChannelModeUnset, I_OnUserModeSet, I_OnUserModeUnset, I_OnChannelModeAdd, I_OnUserModeAdd,
                I_OnMLock, I_OnUnMLock, I_OnServerSync, I_OnUplinkSync, I_OnBotPrivmsg, I_OnPrivmsg, I_OnLog, I_OnDnsRequest,
                I_OnMessage,

                I_OnSerializeCheck, I_OnSerializableConstruct, I_OnSerializableDestruct, I_OnSerializableUpdate, I_OnSerializeTypeCreate,
        I_END
};

class CoreExport ModuleManager
{
 public:
        static std::list<Module *> Modules;

        static std::vector<Module *> EventHandlers[I_END];

        static void CleanupRuntimeDirectory();

        static ModuleReturn LoadModule(const Anope::string &modname, User *u);

        static ModuleReturn UnloadModule(Module *m, User * u);

        static Module *FindModule(const Anope::string &name);

        static Module *FindFirstOf(ModType type);

        static void RequireVersion(int major, int minor, int patch);

        static bool SetPriority(Module *mod, Implementation i, Priority s, Module **modules = NULL, size_t sz = 1);

        static bool SetPriority(Module *mod, Priority s);

        static bool Attach(Implementation i, Module *mod);

        static bool Detach(Implementation i, Module *mod);

        static void DetachAll(Module *mod);

        static void Attach(Implementation *i, Module *mod, size_t sz);

        static void ClearCallBacks(Module *m);

        static void UnloadAll();

 private:
        static ModuleReturn DeleteModule(Module *m);
};

class CoreExport CallBack : public Timer
{
 private:
        Module *m;
 public:
        CallBack(Module *mod, long time_from_now, time_t now = Anope::CurTime, bool repeating = false);

        virtual ~CallBack();
};

#endif // MODULES_H