modules.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
 *                       E-mail:
 *                <brain@chatspike.net>
 *                <Craig@chatspike.net>
 *     
 * Written by Craig Edwards, Craig McLure, and others.
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */


#ifndef __PLUGIN_H
#define __PLUGIN_H

#define DEBUG 10
#define VERBOSE 20
#define DEFAULT 30
#define SPARSE 40
#define NONE 50

#define MT_CHANNEL 1
#define MT_CLIENT 2
#define MT_SERVER 3

#define ACR_DEFAULT 0           // Do default action (act as if the module isnt even loaded)
#define ACR_DENY 1              // deny the action
#define ACR_ALLOW 2             // allow the action
#define AC_KICK 0               // a user is being kicked
#define AC_DEOP 1               // a user is being deopped
#define AC_OP 2                 // a user is being opped
#define AC_VOICE 3              // a user is being voiced
#define AC_DEVOICE 4            // a user is being devoiced
#define AC_HALFOP 5             // a user is being halfopped
#define AC_DEHALFOP 6           // a user is being dehalfopped
#define AC_INVITE 7             // a user is being invited
#define AC_GENERAL_MODE 8       // a user channel mode is being changed

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

#include "dynamic.h"
#include "base.h"
#include "ctables.h"
#include "socket.h"
#include <string>
#include <deque>
#include <sstream>

class Server;

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

typedef std::deque<userrec*> chanuserlist;


// This #define allows us to call a method in all
// loaded modules in a readable simple way, e.g.:
// 'FOREACH_MOD OnConnect(user);'

#define FOREACH_MOD for (int _i = 0; _i <= MODCOUNT; _i++) modules[_i]->

// This define is similar to the one above but returns a result in MOD_RESULT.
// The first module to return a nonzero result is the value to be accepted,
// and any modules after are ignored.

// *********************************************************************************************

#define FOREACH_RESULT(x) { MOD_RESULT = 0; \
                        for (int _i = 0; _i <= MODCOUNT; _i++) { \
                        int res = modules[_i]->x ; \
                        if (res != 0) { \
                                MOD_RESULT = res; \
                                break; \
                        } \
                } \
        } 
   
// *********************************************************************************************

#define FD_MAGIC_NUMBER -42

extern void createcommand(char* cmd, handlerfunc f, char flags, int minparams, char* source);
extern void server_mode(char **parameters, int pcnt, userrec *user);

// class Version holds the version information of a Module, returned
// by Module::GetVersion (thanks RD)

class Version : public classbase
{
 public:
         const int Major, Minor, Revision, Build, Flags;
         Version(int major, int minor, int revision, int build, int flags);
};

class Admin : public classbase
{
 public:
         const std::string Name, Email, Nick;
         Admin(std::string name, std::string email, std::string nick);
};


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

// Thanks to Rob (from anope) for the idea of this message passing API
// (its been done before, but this seemed a very neat and tidy way...

class ModuleMessage : public classbase
{
 public:
        virtual char* Send() = 0;
        virtual ~ModuleMessage() {};
};

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


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

class ExtMode : public classbase
{
 public:
        char modechar;
        int type;
        bool needsoper;
        int params_when_on;
        int params_when_off;
        bool list;
        ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off) { };
};


class Module : public classbase
{
 public:

        Module(Server* Me);

        virtual ~Module();

        virtual Version GetVersion();

        virtual void OnUserConnect(userrec* user);

        virtual void OnUserQuit(userrec* user, std::string message);

        virtual void OnUserDisconnect(userrec* user);

        virtual void OnUserJoin(userrec* user, chanrec* channel);

        virtual void OnUserPart(userrec* user, chanrec* channel);

        virtual void OnRehash(std::string parameter);

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

        virtual int OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params);
        
        virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname);
        
        virtual int OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason);

        virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason);

        virtual void OnOper(userrec* user, std::string opertype);
        
        virtual void OnInfo(userrec* user);
        
        virtual void OnWhois(userrec* source, userrec* dest);
        
        virtual int OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel);
        
        virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel);
        
        virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text);

        virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text);
        
        virtual int OnUserPreNick(userrec* user, std::string newnick);

        virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text);

        virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text);

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

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

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

        virtual void OnSyncChannel(chanrec* 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 userrec or chanrec 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
         */
        virtual void OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, std::string extname);

        /* 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 userrec or chanrec 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
         */
        virtual void OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, std::string extname);

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

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

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

        virtual void OnChangeHost(userrec* user, std::string newhost);

        virtual void OnChangeName(userrec* user, std::string gecos);

        virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask);

        virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask);

        virtual void OnAddKLine(long duration, userrec* source, std::string reason, std::string hostmask);

        virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask);

        virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask);

        virtual void OnDelGLine(userrec* source, std::string hostmask);

        virtual void OnDelZLine(userrec* source, std::string ipmask);

        virtual void OnDelKLine(userrec* source, std::string hostmask);
        
        virtual void OnDelQLine(userrec* source, std::string nickmask);

        virtual void OnDelELine(userrec* source, std::string hostmask);

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

        virtual void OnUserPostNick(userrec* user, std::string oldnick);

        virtual int OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type);

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

        virtual int OnKill(userrec* source, userrec* dest, std::string reason);

        virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason);

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

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

        virtual void OnBackgroundTimer(time_t curtime);

        virtual void OnSendList(userrec* user, chanrec* channel, char mode);

        virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user);

        virtual bool OnCheckReady(userrec* user);

        virtual void OnUserRegister(userrec* user);

        virtual int OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt);

        virtual int OnCheckInvite(userrec* user, chanrec* chan);

        virtual int OnCheckKey(userrec* user, chanrec* chan, std::string keygiven);

        virtual int OnCheckLimit(userrec* user, chanrec* chan);

        virtual int OnCheckBan(userrec* user, chanrec* chan);

        virtual void OnStats(char symbol);

        virtual int OnChangeLocalUserHost(userrec* user, std::string newhost);

        virtual int OnChangeLocalUserGECOS(userrec* user, std::string newhost); 

        virtual int OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic);

        virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic);

        virtual void OnEvent(Event* event);

        virtual char* OnRequest(Request* request);

        virtual int OnOperCompare(std::string password, std::string input);

        virtual void OnGlobalOper(userrec* user);

        virtual void OnGlobalConnect(userrec* user);

        virtual int OnAddBan(userrec* source, chanrec* channel,std::string banmask);

        virtual int OnDelBan(userrec* source, chanrec* channel,std::string banmask);

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

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

        virtual void OnRawSocketClose(int fd);

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


class Server : public classbase
{
 public:
        Server();
        virtual ~Server();
        ServerConfig* GetConfig();
        virtual void SendOpers(std::string s);
        virtual void Log(int level, std::string s);
        virtual void Send(int Socket, std::string s);
        virtual void SendServ(int Socket, std::string s);
        virtual void SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text);
        virtual void SendFrom(int Socket, userrec* User, std::string s);
        virtual void SendTo(userrec* Source, userrec* Dest, std::string s);
        virtual void SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender);
        virtual bool CommonChannels(userrec* u1, userrec* u2);
        virtual void SendCommon(userrec* User, std::string text,bool IncludeSender);
        virtual void SendWallops(userrec* User, std::string text);

        virtual bool IsNick(std::string nick);
        virtual int CountUsers(chanrec* c);
        virtual userrec* FindNick(std::string nick);
        virtual userrec* FindDescriptor(int socket);
        virtual chanrec* FindChannel(std::string channel);
        virtual std::string ChanMode(userrec* User, chanrec* Chan);
        virtual bool IsOnChannel(userrec* User, chanrec* Chan);
        virtual std::string GetServerName();
        virtual std::string GetNetworkName();
        virtual std::string GetServerDescription();
        virtual Admin GetAdmin();
        virtual bool AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off);

        virtual bool AddExtendedListMode(char modechar);

        virtual void AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source);
         
        virtual void SendMode(char **parameters, int pcnt, userrec *user);
        
        virtual void SendToModeMask(std::string modes, int flags, std::string text);

        virtual chanrec* JoinUserToChannel(userrec* user, std::string cname, std::string key);
        
        virtual chanrec* PartUserFromChannel(userrec* user, std::string cname, std::string reason);
        
        virtual void ChangeUserNick(userrec* user, std::string nickname);
        
        virtual void QuitUser(userrec* user, std::string reason);
        
        virtual bool MatchText(std::string sliteral, std::string spattern);
        
        virtual void CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user);

        virtual bool IsValidModuleCommand(std::string commandname, int pcnt, userrec* user);
        
        virtual void ChangeHost(userrec* user, std::string host);
        
        virtual void ChangeGECOS(userrec* user, std::string gecos);
        
        virtual bool IsUlined(std::string server);
        
        virtual chanuserlist GetUsers(chanrec* chan);

        virtual bool UserToPseudo(userrec* user,std::string message);

        virtual bool PseudoToUser(userrec* alive,userrec* zombie,std::string message);

        virtual void AddGLine(long duration, std::string source, std::string reason, std::string hostmask);

        virtual void AddQLine(long duration, std::string source, std::string reason, std::string nickname);

        virtual void AddZLine(long duration, std::string source, std::string reason, std::string ipaddr);

        virtual void AddKLine(long duration, std::string source, std::string reason, std::string hostmask);

        virtual void AddELine(long duration, std::string source, std::string reason, std::string hostmask);

        virtual bool DelGLine(std::string hostmask);

        virtual bool DelQLine(std::string nickname);

        virtual bool DelZLine(std::string ipaddr);

        virtual bool DelKLine(std::string hostmask);

        virtual bool DelELine(std::string hostmask);

        virtual long CalcDuration(std::string duration);

        virtual bool IsValidMask(std::string mask);

        virtual Module* FindModule(std::string name);

        virtual void AddSocket(InspSocket* sock);

        virtual void DelSocket(InspSocket* sock);

        virtual void RehashServer();
};


#define CONF_NOT_A_NUMBER       0x000010
#define CONF_NOT_UNSIGNED       0x000080
#define CONF_VALUE_NOT_FOUND    0x000100
#define CONF_FILE_NOT_FOUND     0x000200


class ConfigReader : public classbase
{
  protected:
        std::stringstream *cache;
        std::stringstream *errorlog;
        bool readerror;
        long error;
        
  public:
        ConfigReader();                 // default constructor reads ircd.conf
        ConfigReader(std::string filename);     // read a module-specific config
        ~ConfigReader();
        std::string ReadValue(std::string tag, std::string name, int index);
        bool ReadFlag(std::string tag, std::string name, int index);
        long ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned);
        long GetError();
        int Enumerate(std::string tag);
        bool Verify();
        void DumpErrors(bool bail,userrec* user);

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



class FileReader : public classbase
{
 file_cache fc;
 public:
         FileReader();

         FileReader(std::string filename);

         ~FileReader();

         void LoadFile(std::string filename);

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

         int FileSize();
};


class ModuleFactory : public classbase
{
 public:
        ModuleFactory() { }
        virtual ~ModuleFactory() { }
        virtual Module * CreateModule(Server* Me) = 0;
};


typedef DLLFactory<ModuleFactory> ircd_module;

#endif

---