Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

modules.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *          the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef __MODULES_H
#define __MODULES_H

#include "dynamic.h"
#include "base.h"
#include "ctables.h"
#include "inspsocket.h"
#include <string>
#include <deque>
#include <sstream>
#include "timer.h"
#include "mode.h"
#include "dns.h"

class XLine;

enum AccessControlType {
        ACR_DEFAULT,            // Do default action (act as if the module isnt even loaded)
        ACR_DENY,               // deny the action
        ACR_ALLOW,              // allow the action
        AC_KICK,                // a user is being kicked
        AC_DEOP,                // a user is being deopped
        AC_OP,                  // a user is being opped
        AC_VOICE,               // a user is being voiced
        AC_DEVOICE,             // a user is being devoiced
        AC_HALFOP,              // a user is being halfopped
        AC_DEHALFOP,            // a user is being dehalfopped
        AC_INVITE,              // a user is being invited
        AC_GENERAL_MODE         // a channel mode is being changed
};

enum ModuleFlags {
        VF_STATIC = 1,          // module is static, cannot be /unloadmodule'd
        VF_VENDOR = 2,          // module is a vendor module (came in the original tarball, not 3rd party)
        VF_SERVICEPROVIDER = 4, // module provides a service to other modules (can be a dependency)
        VF_COMMON = 8           // module needs to be common on all servers in a network to link
};

enum WriteModeFlags {
        WM_AND = 1,
        WM_OR = 2
};

enum TargetTypeFlags {
        TYPE_USER = 1,
        TYPE_CHANNEL,
        TYPE_SERVER,
        TYPE_OTHER
};

enum MessageType {
        MSG_PRIVMSG = 0,
        MSG_NOTICE = 1
};

#define NATIVE_API_VERSION 12000
#ifdef IPV6
#define API_VERSION (NATIVE_API_VERSION * 10)
#else
#define API_VERSION (NATIVE_API_VERSION * 1)
#endif

class ServerConfig;

/* Forward-delacare module for ModuleMessage etc
 */
class Module;
class InspIRCd;

typedef std::deque<std::string> file_cache;

typedef file_cache string_list;

typedef std::map<std::string,Module*> featurelist;

typedef std::deque<Module*> modulelist;

typedef std::map<std::string, std::pair<int, modulelist> > interfacelist;

#define FOREACH_MOD(y,x) do { \
        EventHandlerIter safei; \
        for (EventHandlerIter _i = ServerInstance->Modules->EventHandlers[y].begin(); _i != ServerInstance->Modules->EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        (*_i)->x ; \
                } \
                catch (CoreException& modexcept) \
                { \
                        ServerInstance->Logs->Log("MODULE",DEFAULT,"Exception caught: %s",modexcept.GetReason()); \
                } \
                _i = safei; \
        } \
} while (0);

#define FOREACH_MOD_I(z,y,x) do { \
        EventHandlerIter safei; \
        for (EventHandlerIter _i = z->Modules->EventHandlers[y].begin(); _i != z->Modules->EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        (*_i)->x ; \
                } \
                catch (CoreException& modexcept) \
                { \
                        z->Logs->Log("MODULE",DEFAULT,"Exception caught: %s",modexcept.GetReason()); \
                } \
                _i = safei; \
        } \
} while (0);

#define FOREACH_RESULT(y,x) \
do { \
        EventHandlerIter safei; \
        MOD_RESULT = 0; \
        for (EventHandlerIter _i = ServerInstance->Modules->EventHandlers[y].begin(); _i != ServerInstance->Modules->EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        int res = (*_i)->x ; \
                        if (res != 0) { \
                                MOD_RESULT = res; \
                                break; \
                        } \
                } \
                catch (CoreException& modexcept) \
                { \
                        ServerInstance->Logs->Log("MODULE",DEFAULT,"Exception caught: %s",modexcept.GetReason()); \
                } \
                _i = safei; \
        } \
} while(0);


#define FOREACH_RESULT_I(z,y,x) \
do { \
        EventHandlerIter safei; \
        MOD_RESULT = 0; \
        for (EventHandlerIter _i = z->Modules->EventHandlers[y].begin(); _i != z->Modules->EventHandlers[y].end(); ) \
        { \
                safei = _i; \
                ++safei; \
                try \
                { \
                        int res = (*_i)->x ; \
                        if (res != 0) { \
                                MOD_RESULT = res; \
                                break; \
                        } \
                } \
                catch (CoreException& modexcept) \
                { \
                        z->Logs->Log("MODULE",DEBUG,"Exception caught: %s",modexcept.GetReason()); \
                } \
                _i = safei; \
        } \
} while (0);

#define FD_MAGIC_NUMBER -42

/* Useful macros */

#define IS_LOCAL(x) ((x->GetFd() > -1))

#define IS_REMOTE(x) (x->GetFd() < 0)

#define IS_MODULE_CREATED(x) (x->GetFd() == FD_MAGIC_NUMBER)

#define IS_OPER(x) (!x->oper.empty())

#define IS_AWAY(x) (!x->awaymsg.empty())

class CoreExport Version : public classbase
{
 public:
        std::string version;

        const int Flags, API;

        Version(const std::string &sversion, int flags, int api_ver);
};

class CoreExport ModuleMessage : public Extensible
{
 public:
        virtual ~ModuleMessage() {};
};

class CoreExport Request : public ModuleMessage
{
 protected:
        char* data;
        const char* id;
        Module* source;
        Module* dest;
 public:
        Request(char* anydata, Module* src, Module* dst);
        Request(Module* src, Module* dst, const char* idstr);
        char* GetData();
        const char* GetId();
        Module* GetSource();
        Module* GetDest();
        const char* Send();
};


class CoreExport Event : public ModuleMessage
{
 protected:
        char* data;
        Module* source;
        std::string id;
 public:
        Event(char* anydata, Module* src, const std::string &eventid);
        char* GetData();
        Module* GetSource();
        std::string GetEventID();
        char* Send(InspIRCd* ServerInstance);
};

enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };

enum Implementation
{
        I_BEGIN,
        I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash, I_OnServerRaw, I_OnSendSnotice,
        I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois, I_OnUserPreInvite,
        I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNotice, I_OnUserPreNick, I_OnUserMessage, I_OnUserNotice, I_OnMode,
        I_OnGetServerDescription, I_OnSyncUser, I_OnSyncChannel, I_OnSyncChannelMetaData, I_OnSyncUserMetaData,
        I_OnDecodeMetaData, I_ProtoSendMode, I_ProtoSendMetaData, I_OnWallops, I_OnChangeHost, I_OnChangeName, I_OnAddLine,
        I_OnDelLine, I_OnExpireLine, I_OnCleanup, I_OnUserPostNick, I_OnAccessCheck, I_On005Numeric, I_OnKill, I_OnRemoteKill, I_OnLoadModule, I_OnUnloadModule,
        I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnCheckInvite, I_OnRawMode,
        I_OnCheckKey, I_OnCheckLimit, I_OnCheckBan, I_OnCheckExtBan, I_OnCheckStringExtBan, I_OnStats, I_OnChangeLocalUserHost, I_OnChangeLocalUserGecos, 
        I_OnLocalTopicChange, I_OnPostLocalTopicChange, I_OnEvent, I_OnRequest, I_OnGlobalOper, I_OnPostConnect, I_OnAddBan, I_OnDelBan,
        I_OnRawSocketAccept, I_OnRawSocketClose, I_OnRawSocketWrite, I_OnRawSocketRead, I_OnChangeLocalUserGECOS, I_OnUserRegister,
        I_OnChannelPreDelete, I_OnChannelDelete, I_OnPostOper, I_OnSyncOtherMetaData, I_OnSetAway, I_OnUserList,
        I_OnPostCommand, I_OnPostJoin, I_OnWhoisLine, I_OnBuildExemptList, I_OnRawSocketConnect, I_OnGarbageCollect, I_OnBufferFlushed,
        I_OnText, I_OnPassCompare, I_OnRunTestSuite, I_OnNamesListItem, I_OnNumeric, I_OnHookUserIO, I_OnHostCycle,
        I_END
};

class ConfigReader;

class CoreExport Module : public Extensible
{
 protected:
        InspIRCd* ServerInstance;
 public:

        Module(InspIRCd* Me);

        virtual ~Module();

        virtual void Prioritize()
        {
        }

        virtual Version GetVersion();

        virtual void OnUserConnect(User* user);

        virtual void OnUserQuit(User* user, const std::string &message, const std::string &oper_message);

        virtual void OnUserDisconnect(User* user);

        virtual int OnChannelPreDelete(Channel *chan);

        virtual void OnChannelDelete(Channel* chan);

        virtual void OnUserJoin(User* user, Channel* channel, bool sync, bool &silent);

        virtual void OnPostJoin(User* user, Channel* channel);

        virtual void OnUserPart(User* user, Channel* channel, std::string &partmessage, bool &silent);

        virtual void OnRehash(User* user, const std::string &parameter);

        virtual void OnServerRaw(std::string &raw, bool inbound, User* user);

        virtual int OnSendSnotice(char &snomask, std::string &type, const std::string &message);

        virtual int OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string &privs, const std::string &keygiven);
        
        virtual int OnUserPreKick(User* source, User* user, Channel* chan, const std::string &reason);

        virtual void OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent);

        virtual void OnOper(User* user, const std::string &opertype);

        virtual void OnPostOper(User* user, const std::string &opername, const std::string &opertype);
        
        virtual void OnInfo(User* user);
        
        virtual void OnWhois(User* source, User* dest);
        
        virtual int OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout);
        
        virtual void OnUserInvite(User* source,User* dest,Channel* channel, time_t timeout);
        
        virtual int OnUserPreMessage(User* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list);

        virtual int OnUserPreNotice(User* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list);

        virtual void OnBuildExemptList(MessageType message_type, Channel* chan, User* sender, char status, CUList &exempt_list, const std::string &text);
        
        virtual int OnUserPreNick(User* user, const std::string &newnick);

        virtual void OnUserMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list);

        virtual void OnUserNotice(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list);

        virtual void OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list);

        virtual void OnMode(User* user, void* dest, int target_type, const std::string &text);

        virtual void OnGetServerDescription(const std::string &servername,std::string &description);

        virtual void OnSyncUser(User* user, Module* proto, void* opaque);

        virtual void OnSyncChannel(Channel* chan, Module* proto, void* opaque);

        /* Allows modules to syncronize metadata related to channels over the network during a netburst.
         * Whenever the linking module wants to send out data, but doesnt know what the data
         * represents (e.g. it is Extensible metadata, added to a User or Channel by a module) then
         * this method is called.You should use the ProtoSendMetaData function after you've
         * correctly decided how the data should be represented, to send the metadata on its way if it belongs
         * to your module. For a good example of how to use this method, see src/modules/m_swhois.cpp.
         * @param chan The channel whos metadata is being syncronized
         * @param proto A pointer to the module handling network protocol
         * @param opaque An opaque pointer set by the protocol module, should not be modified!
         * @param extname The extensions name which is being searched for
         * @param displayable If this value is true, the data is going to be displayed to a user,
         * and not sent across the network. Use this to determine wether or not to show sensitive data.
         */
        virtual void OnSyncChannelMetaData(Channel* chan, Module* proto,void* opaque, const std::string &extname, bool displayable = false);

        /* Allows modules to syncronize metadata related to users over the network during a netburst.
         * Whenever the linking module wants to send out data, but doesnt know what the data
         * represents (e.g. it is Extensible metadata, added to a User or Channel by a module) then
         * this method is called. You should use the ProtoSendMetaData function after you've
         * correctly decided how the data should be represented, to send the metadata on its way if
         * if it belongs to your module.
         * @param user The user whos metadata is being syncronized
         * @param proto A pointer to the module handling network protocol
         * @param opaque An opaque pointer set by the protocol module, should not be modified!
         * @param extname The extensions name which is being searched for
         * @param displayable If this value is true, the data is going to be displayed to a user,
         * and not sent across the network. Use this to determine wether or not to show sensitive data.
         */
        virtual void OnSyncUserMetaData(User* user, Module* proto,void* opaque, const std::string &extname, bool displayable = false);

        /* Allows modules to syncronize metadata not related to users or channels, over the network during a netburst.
         * Whenever the linking module wants to send out data, but doesnt know what the data
         * represents (e.g. it is Extensible metadata, added to a User or Channel by a module) then
         * this method is called. You should use the ProtoSendMetaData function after you've
         * correctly decided how the data should be represented, to send the metadata on its way if
         * if it belongs to your module.
         * @param proto A pointer to the module handling network protocol
         * @param opaque An opaque pointer set by the protocol module, should not be modified!
         * @param displayable If this value is true, the data is going to be displayed to a user,
         * and not sent across the network. Use this to determine wether or not to show sensitive data.
         */
        virtual void OnSyncOtherMetaData(Module* proto, void* opaque, bool displayable = false);

        virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata);

        virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline);

        virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata);
        
        virtual void OnWallops(User* user, const std::string &text);

        virtual void OnChangeHost(User* user, const std::string &newhost);

        virtual void OnChangeName(User* user, const std::string &gecos);

        virtual void OnAddLine(User* source, XLine* line);

        virtual void OnDelLine(User* source, XLine* line);

        virtual void OnExpireLine(XLine *line);

        virtual void OnCleanup(int target_type, void* item);

        virtual void OnUserPostNick(User* user, const std::string &oldnick);

        virtual int OnAccessCheck(User* source,User* dest,Channel* channel,int access_type);

        virtual void On005Numeric(std::string &output);

        virtual int OnKill(User* source, User* dest, const std::string &reason);

        virtual void OnRemoteKill(User* source, User* dest, const std::string &reason, const std::string &operreason);

        virtual void OnLoadModule(Module* mod,const std::string &name);

        virtual void OnUnloadModule(Module* mod,const std::string &name);

        virtual void OnBackgroundTimer(time_t curtime);

        virtual int OnPreCommand(std::string &command, std::vector<std::string>& parameters, User *user, bool validated, const std::string &original_line);

        virtual void OnPostCommand(const std::string &command, const std::vector<std::string>& parameters, User *user, CmdResult result, const std::string &original_line);

        virtual bool OnCheckReady(User* user);

        virtual int OnUserRegister(User* user);

        virtual int OnCheckInvite(User* user, Channel* chan);

        virtual int OnRawMode(User* user, Channel* chan, const char mode, const std::string &param, bool adding, int pcnt, bool servermode = true);

        virtual int OnCheckKey(User* user, Channel* chan, const std::string &keygiven);

        virtual int OnCheckLimit(User* user, Channel* chan);

        virtual int OnCheckBan(User* user, Channel* chan);

        /* Called whenever checking whether or not a user is matched by an applicable extended bantype.
         * NOTE: may also trigger extra OnCheckStringExtBan events!
         * @param u The user to check
         * @param c The channel the user is on
         * @param type The type of extended ban to check for.
         */
        virtual int OnCheckExtBan(User *u, Channel *c, char type);

        virtual int OnCheckStringExtBan(const std::string &s, Channel *c, char type);

        virtual int OnStats(char symbol, User* user, string_list &results);

        virtual int OnChangeLocalUserHost(User* user, const std::string &newhost);

        virtual int OnChangeLocalUserGECOS(User* user, const std::string &newhost); 

        virtual int OnLocalTopicChange(User* user, Channel* chan, const std::string &topic);

        virtual void OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic);

        virtual void OnEvent(Event* event);

        virtual const char* OnRequest(Request* request);

        virtual int OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype);

        virtual void OnGlobalOper(User* user);

        virtual void OnPostConnect(User* user);

        virtual int OnAddBan(User* source, Channel* channel,const std::string &banmask);

        virtual int OnDelBan(User* source, Channel* channel,const std::string &banmask);

        virtual void OnHookUserIO(User* user, const std::string &targetip);

        virtual void OnRawSocketAccept(int fd, const std::string &ip, int localport);

        virtual int OnRawSocketWrite(int fd, const char* buffer, int count);

        virtual void OnRawSocketClose(int fd);

        virtual void OnRawSocketConnect(int fd);

        virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult);

        virtual int OnSetAway(User* user, const std::string &awaymsg);

        virtual int OnUserList(User* user, Channel* Ptr, CUList* &userlist);

        virtual int OnWhoisLine(User* user, User* dest, int &numeric, std::string &text);

        virtual void OnGarbageCollect();

        virtual void OnBufferFlushed(User* user);

        virtual void OnRunTestSuite();

        virtual void OnNamesListItem(User* issuer, User* user, Channel* channel, std::string &prefixes, std::string &nick);

        virtual int OnNumeric(User* user, unsigned int numeric, const std::string &text);

        virtual bool OnHostCycle(User* user);
};


#define CONF_NO_ERROR           0x000000
#define CONF_NOT_A_NUMBER       0x000010
#define CONF_INT_NEGATIVE       0x000080
#define CONF_VALUE_NOT_FOUND    0x000100
#define CONF_FILE_NOT_FOUND     0x000200


class CoreExport ConfigReader : public classbase
{
  protected:
        InspIRCd* ServerInstance;
        ConfigDataHash* data;
        std::ostringstream* errorlog;
        bool privatehash;
        bool readerror;
        long error;
        
  public:
        ConfigReader(InspIRCd* Instance);
        ConfigReader(InspIRCd* Instance, const std::string &filename);
        ~ConfigReader();

        std::string ReadValue(const std::string &tag, const std::string &name, int index, bool allow_linefeeds = false);
        std::string ReadValue(const std::string &tag, const std::string &name, const std::string &default_value, int index, bool allow_linefeeds = false);

        bool ReadFlag(const std::string &tag, const std::string &name, int index);
        bool ReadFlag(const std::string &tag, const std::string &name, const std::string &default_value, int index);

        int ReadInteger(const std::string &tag, const std::string &name, int index, bool need_positive);
        int ReadInteger(const std::string &tag, const std::string &name, const std::string &default_value, int index, bool need_positive);

        long GetError();
        int Enumerate(const std::string &tag);
        bool Verify();
        void DumpErrors(bool bail,User* user);

        int EnumerateValues(const std::string &tag, int index);
};



class CoreExport FileReader : public classbase
{
        InspIRCd* ServerInstance;
        file_cache fc;

        unsigned long contentsize;

        void CalcSize();

 public:
        FileReader(InspIRCd* Instance);

        FileReader(InspIRCd* Instance, const std::string &filename);

        ~FileReader();

        void LoadFile(const std::string &filename);

        std::string Contents();

        unsigned long ContentSize();

        bool Exists();
 
        std::string GetLine(int x);

        int FileSize();
};

typedef DLLFactory<Module> ircd_module;

typedef std::vector<Module*> IntModuleList;

typedef IntModuleList::iterator EventHandlerIter;

enum PriorityState
{
        PRIO_DONTCARE,
        PRIO_FIRST,
        PRIO_LAST,
        PRIO_AFTER,
        PRIO_BEFORE
};

class CoreExport ModuleManager : public classbase
{
 private:
        std::string LastModuleError;
 
        featurelist Features;

        interfacelist Interfaces;
 
        int ModCount; 
        
        InspIRCd* Instance;

        std::map<std::string, std::pair<ircd_module*, Module*> > Modules;

 public:

        IntModuleList EventHandlers[I_END];

        ModuleManager(InspIRCd* Ins);

        ~ModuleManager(); 

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

        bool SetPriority(Module* mod, PriorityState s);

        bool Attach(Implementation i, Module* mod);

        bool Detach(Implementation i, Module* mod);

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

        void DetachAll(Module* mod);
 
        std::string& LastError();

        bool Load(const char* filename);

        bool Unload(const char* filename);
        
        void LoadAll();
        
        int GetCount()
        {
                return this->ModCount;
        }
        
        Module* Find(const std::string &name);
 
        bool PublishFeature(const std::string &FeatureName, Module* Mod);

        bool PublishInterface(const std::string &InterfaceName, Module* Mod);

        std::pair<int,std::string> GetInterfaceInstanceCount(Module* m);

        void UseInterface(const std::string &InterfaceName);

        void DoneWithInterface(const std::string &InterfaceName);

        bool UnpublishFeature(const std::string &FeatureName);

        bool UnpublishInterface(const std::string &InterfaceName, Module* Mod);

        Module* FindFeature(const std::string &FeatureName);

        modulelist* FindInterface(const std::string &InterfaceName);

        bool ModuleHasInterface(Module* mod, const std::string& InterfaceName);

        const std::string& GetModuleName(Module* m);

        const std::vector<std::string> GetAllModuleNames(int filter);
};

#ifdef WINDOWS

#define MODULE_INIT(y) \
        extern "C" DllExport Module * init_module(InspIRCd* Me) \
        { \
                return new y(Me); \
        } \
        BOOLEAN WINAPI DllMain(HINSTANCE hDllHandle, DWORD nReason, LPVOID Reserved) \
        { \
                switch ( nReason ) \
                { \
                        case DLL_PROCESS_ATTACH: \
                        case DLL_PROCESS_DETACH: \
                                break; \
                } \
                return TRUE; \
        }

#else

#define MODULE_INIT(y) \
        extern "C" DllExport Module * init_module(InspIRCd* Me) \
        { \
                return new y(Me); \
        }
#endif

#endif