Modules.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2014 ZNC, see the NOTICE file for details.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _MODULES_H
#define _MODULES_H

#include <znc/zncconfig.h>
#include <znc/WebModules.h>
#include <znc/main.h>
#include <set>
#include <queue>

// Forward Declarations
class CAuthBase;
class CChan;
class CIRCNetwork;
class CClient;
class CWebSock;
class CTemplate;
class CIRCSock;
class CModule;
class CModInfo;
// !Forward Declarations

#ifdef REQUIRESSL
#ifndef HAVE_LIBSSL
#error -
#error -
#error This module only works when ZNC is compiled with OpenSSL support
#error -
#error -
#endif
#endif

typedef void* ModHandle;

template<class M> void TModInfo(CModInfo& Info) {}

template<class M> CModule* TModLoad(ModHandle p, CUser* pUser,
                CIRCNetwork* pNetwork, const CString& sModName,
                const CString& sModPath) {
        return new M(p, pUser, pNetwork, sModName, sModPath);
}

#if HAVE_VISIBILITY
# define MODULE_EXPORT __attribute__((__visibility__("default")))
#else
# define MODULE_EXPORT
#endif

#define MODCOMMONDEFS(CLASS, DESCRIPTION, TYPE) \
        extern "C" { \
                MODULE_EXPORT bool ZNCModInfo(double dCoreVersion, CModInfo& Info); \
                bool ZNCModInfo(double dCoreVersion, CModInfo& Info) { \
                        if (dCoreVersion != VERSION) \
                                return false; \
                        Info.SetDescription(DESCRIPTION); \
                        Info.SetDefaultType(TYPE); \
                        Info.AddType(TYPE); \
                        Info.SetLoader(TModLoad<CLASS>); \
                        TModInfo<CLASS>(Info); \
                        return true; \
                } \
        }

#define MODCONSTRUCTOR(CLASS) \
        CLASS(ModHandle pDLL, CUser* pUser, CIRCNetwork* pNetwork, const CString& sModName, \
                        const CString& sModPath) \
                        : CModule(pDLL, pUser, pNetwork, sModName, sModPath)

// User Module Macros
#define USERMODULEDEFS(CLASS, DESCRIPTION) \
        MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::UserModule)
// !User Module Macros

// Global Module Macros
#define GLOBALMODULEDEFS(CLASS, DESCRIPTION) \
        MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::GlobalModule)
// !Global Module Macros

// Network Module Macros
#define NETWORKMODULEDEFS(CLASS, DESCRIPTION) \
        MODCOMMONDEFS(CLASS, DESCRIPTION, CModInfo::NetworkModule)
// !Network Module Macros

#define MODULEDEFS(CLASS, DESCRIPTION) NETWORKMODULEDEFS(CLASS, DESCRIPTION)

// Forward Declarations
class CZNC;
class CUser;
class CNick;
class CChan;
class CModule;
class CFPTimer;
class CSockManager;
// !Forward Declarations

class CTimer : public CCron {
public:
        CTimer(CModule* pModule, unsigned int uInterval, unsigned int uCycles, const CString& sLabel, const CString& sDescription);

        virtual ~CTimer();

        // Setters
        void SetModule(CModule* p);
        void SetDescription(const CString& s);
        // !Setters

        // Getters
        CModule* GetModule() const;
        const CString& GetDescription() const;
        // !Getters
private:
protected:
        CModule*   m_pModule;
        CString    m_sDescription;
};

typedef void (*FPTimer_t)(CModule *, CFPTimer *);

class CFPTimer : public CTimer {
public:
        CFPTimer(CModule* pModule, unsigned int uInterval, unsigned int uCycles, const CString& sLabel, const CString& sDescription)
                : CTimer(pModule, uInterval, uCycles, sLabel, sDescription) {
                m_pFBCallback = NULL;
        }

        virtual ~CFPTimer() {}

        void SetFPCallback(FPTimer_t p) { m_pFBCallback = p; }

protected:
        virtual void RunJob() {
                if (m_pFBCallback) {
                        m_pFBCallback(m_pModule, this);
                }
        }

private:
        FPTimer_t  m_pFBCallback;
};

class CModInfo {
public:
        typedef CModule* (*ModLoader)(ModHandle p, CUser* pUser, CIRCNetwork* pNetwork, const CString& sModName, const CString& sModPath);

        typedef enum {
                GlobalModule,
                UserModule,
                NetworkModule
        } EModuleType;

        CModInfo() {
                m_fLoader = NULL;
                m_bHasArgs = false;
        }
        CModInfo(const CString& sName, const CString& sPath, EModuleType eType) {
                m_sName = sName;
                m_sPath = sPath;
                m_fLoader = NULL;
                m_bHasArgs = false;
        }
        ~CModInfo() {}

        bool operator < (const CModInfo& Info) const {
                return (GetName() < Info.GetName());
        }

        bool SupportsType(EModuleType eType) {
                return m_seType.find(eType) != m_seType.end();
        }

        void AddType(EModuleType eType) {
                m_seType.insert(eType);
        }

        static CString ModuleTypeToString(EModuleType eType) {
                switch (eType) {
                case GlobalModule: return "Global";
                case UserModule: return "User";
                case NetworkModule: return "Network";
                default: return "UNKNOWN";
                }
        }

        // Getters
        const CString& GetName() const { return m_sName; }
        const CString& GetPath() const { return m_sPath; }
        const CString& GetDescription() const { return m_sDescription; }
        const CString& GetWikiPage() const { return m_sWikiPage; }
        const CString& GetArgsHelpText() const { return m_sArgsHelpText; }
        bool GetHasArgs() const { return m_bHasArgs; }
        ModLoader GetLoader() const { return m_fLoader; }
        EModuleType GetDefaultType() const { return m_eDefaultType; }
        // !Getters

        // Setters
        void SetName(const CString& s) { m_sName = s; }
        void SetPath(const CString& s) { m_sPath = s; }
        void SetDescription(const CString& s) { m_sDescription = s; }
        void SetWikiPage(const CString& s) { m_sWikiPage = s; }
        void SetArgsHelpText(const CString& s) { m_sArgsHelpText = s; }
        void SetHasArgs(bool b = false) { m_bHasArgs = b; }
        void SetLoader(ModLoader fLoader) { m_fLoader = fLoader; }
        void SetDefaultType(EModuleType eType) { m_eDefaultType = eType; }
        // !Setters
private:
protected:
        std::set<EModuleType> m_seType;
        EModuleType     m_eDefaultType;
        CString         m_sName;
        CString         m_sPath;
        CString         m_sDescription;
        CString         m_sWikiPage;
        CString         m_sArgsHelpText;
        bool            m_bHasArgs;
        ModLoader       m_fLoader;
};

class CModCommand {
public:
        typedef void (CModule::*ModCmdFunc)(const CString& sLine);

        CModCommand();

        CModCommand(const CString& sCmd, ModCmdFunc func, const CString& sArgs, const CString& sDesc);

        CModCommand(const CModCommand& other);

        CModCommand& operator=(const CModCommand& other);

        static void InitHelp(CTable& Table);

        void AddHelp(CTable& Table) const;

        const CString& GetCommand() const { return m_sCmd; }
        ModCmdFunc GetFunction() const { return m_pFunc; }
        const CString& GetArgs() const { return m_sArgs; }
        const CString& GetDescription() const { return m_sDesc; }

        void Call(CModule *pMod, const CString& sLine) const { (pMod->*m_pFunc)(sLine); }

private:
        CString m_sCmd;
        ModCmdFunc m_pFunc;
        CString m_sArgs;
        CString m_sDesc;
};

class CModule {
public:
        CModule(ModHandle pDLL, CUser* pUser, CIRCNetwork* pNetwork, const CString& sModName,
                        const CString& sDataDir);
        virtual ~CModule();

        typedef enum {
                CONTINUE = 1,
                HALT     = 2,
                HALTMODS = 3,
                HALTCORE = 4
        } EModRet;

        typedef enum {
                UNLOAD
        } EModException;

        void SetUser(CUser* pUser);
        void SetNetwork(CIRCNetwork* pNetwork);
        void SetClient(CClient* pClient);

        void Unload() { throw UNLOAD; }

        virtual bool OnLoad(const CString& sArgsi, CString& sMessage);
        virtual bool OnBoot();


        virtual bool WebRequiresLogin() { return true; }
        virtual bool WebRequiresAdmin() { return false; }
        virtual CString GetWebMenuTitle() { return ""; }
        virtual CString GetWebPath();
        virtual CString GetWebFilesPath();
        virtual bool OnWebPreRequest(CWebSock& WebSock, const CString& sPageName);
        virtual bool OnWebRequest(CWebSock& WebSock, const CString& sPageName, CTemplate& Tmpl);
        virtual void AddSubPage(TWebSubPage spSubPage) { m_vSubPages.push_back(spSubPage); }
        virtual void ClearSubPages() { m_vSubPages.clear(); }
        virtual VWebSubPages& GetSubPages() { return m_vSubPages; }
        virtual bool OnEmbeddedWebRequest(CWebSock& WebSock, const CString& sPageName, CTemplate& Tmpl);


        virtual void OnPreRehash();
        virtual void OnPostRehash();
        virtual void OnIRCDisconnected();
        virtual void OnIRCConnected();
        virtual EModRet OnIRCConnecting(CIRCSock *pIRCSock);
        virtual void OnIRCConnectionError(CIRCSock *pIRCSock);
        virtual EModRet OnIRCRegistration(CString& sPass, CString& sNick, CString& sIdent, CString& sRealName);
        virtual EModRet OnBroadcast(CString& sMessage);

        virtual void OnChanPermission2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, unsigned char uMode, bool bAdded, bool bNoChange);
        virtual void OnChanPermission(const CNick& OpNick, const CNick& Nick, CChan& Channel, unsigned char uMode, bool bAdded, bool bNoChange);
        virtual void OnOp2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnOp(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnDeop2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnDeop(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnVoice2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnVoice(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnDevoice2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnDevoice(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        virtual void OnMode2(const CNick* pOpNick, CChan& Channel, char uMode, const CString& sArg, bool bAdded, bool bNoChange);
        virtual void OnMode(const CNick& OpNick, CChan& Channel, char uMode, const CString& sArg, bool bAdded, bool bNoChange);
        virtual void OnRawMode2(const CNick* pOpNick, CChan& Channel, const CString& sModes, const CString& sArgs);
        virtual void OnRawMode(const CNick& OpNick, CChan& Channel, const CString& sModes, const CString& sArgs);

        virtual EModRet OnRaw(CString& sLine);

        virtual EModRet OnStatusCommand(CString& sCommand);
        virtual void OnModCommand(const CString& sCommand);
        virtual void OnUnknownModCommand(const CString& sCommand);
        virtual void OnModNotice(const CString& sMessage);
        virtual void OnModCTCP(const CString& sMessage);

        virtual void OnQuit(const CNick& Nick, const CString& sMessage, const std::vector<CChan*>& vChans);
        virtual void OnNick(const CNick& Nick, const CString& sNewNick, const std::vector<CChan*>& vChans);
        virtual void OnKick(const CNick& OpNick, const CString& sKickedNick, CChan& Channel, const CString& sMessage);
        virtual void OnJoin(const CNick& Nick, CChan& Channel);
        virtual void OnPart(const CNick& Nick, CChan& Channel, const CString& sMessage);
        virtual EModRet OnInvite(const CNick& Nick, const CString& sChan);

        virtual EModRet OnChanBufferStarting(CChan& Chan, CClient& Client);
        virtual EModRet OnChanBufferEnding(CChan& Chan, CClient& Client);
        virtual EModRet OnChanBufferPlayLine(CChan& Chan, CClient& Client, CString& sLine);
        virtual EModRet OnPrivBufferPlayLine(CClient& Client, CString& sLine);

        virtual void OnClientLogin();
        virtual void OnClientDisconnect();
        virtual EModRet OnUserRaw(CString& sLine);
        virtual EModRet OnUserCTCPReply(CString& sTarget, CString& sMessage);
        virtual EModRet OnUserCTCP(CString& sTarget, CString& sMessage);
        virtual EModRet OnUserAction(CString& sTarget, CString& sMessage);
        virtual EModRet OnUserMsg(CString& sTarget, CString& sMessage);
        virtual EModRet OnUserNotice(CString& sTarget, CString& sMessage);
        virtual EModRet OnUserJoin(CString& sChannel, CString& sKey);
        virtual EModRet OnUserPart(CString& sChannel, CString& sMessage);
        virtual EModRet OnUserTopic(CString& sChannel, CString& sTopic);
        virtual EModRet OnUserTopicRequest(CString& sChannel);

        virtual EModRet OnCTCPReply(CNick& Nick, CString& sMessage);
        virtual EModRet OnPrivCTCP(CNick& Nick, CString& sMessage);
        virtual EModRet OnChanCTCP(CNick& Nick, CChan& Channel, CString& sMessage);
        virtual EModRet OnPrivAction(CNick& Nick, CString& sMessage);
        virtual EModRet OnChanAction(CNick& Nick, CChan& Channel, CString& sMessage);
        virtual EModRet OnPrivMsg(CNick& Nick, CString& sMessage);
        virtual EModRet OnChanMsg(CNick& Nick, CChan& Channel, CString& sMessage);
        virtual EModRet OnPrivNotice(CNick& Nick, CString& sMessage);
        virtual EModRet OnChanNotice(CNick& Nick, CChan& Channel, CString& sMessage);
        virtual EModRet OnTopic(CNick& Nick, CChan& Channel, CString& sTopic);

        virtual bool OnServerCapAvailable(const CString& sCap);
        virtual void OnServerCapResult(const CString& sCap, bool bSuccess);

        virtual EModRet OnTimerAutoJoin(CChan& Channel);

        virtual EModRet OnAddNetwork(CIRCNetwork& Network, CString& sErrorRet);
        virtual EModRet OnDeleteNetwork(CIRCNetwork& Network);

        virtual EModRet OnSendToClient(CString& sLine, CClient& Client);
        virtual EModRet OnSendToIRC(CString& sLine);

        ModHandle GetDLL() { return m_pDLL; }
        static double GetCoreVersion() { return VERSION; }

        virtual bool PutIRC(const CString& sLine);
        virtual bool PutUser(const CString& sLine);
        virtual bool PutStatus(const CString& sLine);
        virtual bool PutModule(const CString& sLine);
        virtual unsigned int PutModule(const CTable& table);
        virtual bool PutModNotice(const CString& sLine);

        const CString& GetModName() const { return m_sModName; }

        CString GetModNick() const;

        const CString& GetModDataDir() const { return m_sDataDir; }

        // Timer stuff
        bool AddTimer(CTimer* pTimer);
        bool AddTimer(FPTimer_t pFBCallback, const CString& sLabel, u_int uInterval, u_int uCycles = 0, const CString& sDescription = "");
        bool RemTimer(CTimer* pTimer);
        bool RemTimer(const CString& sLabel);
        bool UnlinkTimer(CTimer* pTimer);
        CTimer* FindTimer(const CString& sLabel);
        std::set<CTimer*>::const_iterator BeginTimers() const { return m_sTimers.begin(); }
        std::set<CTimer*>::const_iterator EndTimers() const { return m_sTimers.end(); }
        virtual void ListTimers();
        // !Timer stuff

        // Socket stuff
        bool AddSocket(CSocket* pSocket);
        bool RemSocket(CSocket* pSocket);
        bool RemSocket(const CString& sSockName);
        bool UnlinkSocket(CSocket* pSocket);
        CSocket* FindSocket(const CString& sSockName);
        std::set<CSocket*>::const_iterator BeginSockets() const { return m_sSockets.begin(); }
        std::set<CSocket*>::const_iterator EndSockets() const { return m_sSockets.end(); }
        virtual void ListSockets();
        // !Socket stuff

        // Command stuff
        void AddHelpCommand();
        bool AddCommand(const CModCommand& Command);
        bool AddCommand(const CString& sCmd, CModCommand::ModCmdFunc func, const CString& sArgs = "", const CString& sDesc = "");
        bool RemCommand(const CString& sCmd);
        const CModCommand* FindCommand(const CString& sCmd) const;
        bool HandleCommand(const CString& sLine);
        void HandleHelpCommand(const CString& sLine = "");
        // !Command stuff

        bool LoadRegistry();
        bool SaveRegistry() const;
        bool SetNV(const CString & sName, const CString & sValue, bool bWriteToDisk = true);
        CString GetNV(const CString & sName) const;
        bool DelNV(const CString & sName, bool bWriteToDisk = true);
        MCString::iterator FindNV(const CString & sName) { return m_mssRegistry.find(sName); }
        MCString::iterator EndNV() { return m_mssRegistry.end(); }
        MCString::iterator BeginNV() { return m_mssRegistry.begin(); }
        void DelNV(MCString::iterator it) { m_mssRegistry.erase(it); }
        bool ClearNV(bool bWriteToDisk = true);

        const CString& GetSavePath() const;
        CString ExpandString(const CString& sStr) const;
        CString& ExpandString(const CString& sStr, CString& sRet) const;

        // Setters
        void SetType(CModInfo::EModuleType eType) { m_eType = eType; }
        void SetDescription(const CString& s) { m_sDescription = s; }
        void SetModPath(const CString& s) { m_sModPath = s; }
        void SetArgs(const CString& s) { m_sArgs = s; }
        // !Setters

        // Getters
        CModInfo::EModuleType GetType() const { return m_eType; }
        const CString& GetDescription() const { return m_sDescription; }
        const CString& GetArgs() const { return m_sArgs; }
        const CString& GetModPath() const { return m_sModPath; }

        CUser* GetUser() { return m_pUser; }
        CIRCNetwork* GetNetwork() { return m_pNetwork; }
        CClient* GetClient() { return m_pClient; }
        CSockManager* GetManager() { return m_pManager; }
        // !Getters

        // Global Modules
        virtual EModRet OnAddUser(CUser& User, CString& sErrorRet);
        virtual EModRet OnDeleteUser(CUser& User);
        virtual void OnClientConnect(CZNCSock* pSock, const CString& sHost, unsigned short uPort);
        virtual EModRet OnLoginAttempt(CSmartPtr<CAuthBase> Auth);
        virtual void OnFailedLogin(const CString& sUsername, const CString& sRemoteIP);
        virtual EModRet OnUnknownUserRaw(CClient* pClient, CString& sLine);

        virtual void OnClientCapLs(CClient* pClient, SCString& ssCaps);
        virtual bool IsClientCapSupported(CClient* pClient, const CString& sCap, bool bState);
        virtual void OnClientCapRequest(CClient* pClient, const CString& sCap, bool bState);

        virtual EModRet OnModuleLoading(const CString& sModName, const CString& sArgs,
                        CModInfo::EModuleType eType, bool& bSuccess, CString& sRetMsg);
        virtual EModRet OnModuleUnloading(CModule* pModule, bool& bSuccess, CString& sRetMsg);
        virtual EModRet OnGetModInfo(CModInfo& ModInfo, const CString& sModule,
                        bool& bSuccess, CString& sRetMsg);
        virtual void OnGetAvailableMods(std::set<CModInfo>& ssMods, CModInfo::EModuleType eType);
        // !Global Modules

protected:
        CModInfo::EModuleType m_eType;
        CString            m_sDescription;
        std::set<CTimer*>  m_sTimers;
        std::set<CSocket*> m_sSockets;
        ModHandle          m_pDLL;
        CSockManager*      m_pManager;
        CUser*             m_pUser;
        CIRCNetwork*       m_pNetwork;
        CClient*           m_pClient;
        CString            m_sModName;
        CString            m_sDataDir;
        CString            m_sSavePath;
        CString            m_sArgs;
        CString            m_sModPath;
private:
        MCString           m_mssRegistry; 
        VWebSubPages       m_vSubPages;
        std::map<CString, CModCommand> m_mCommands;
};

class CModules : public std::vector<CModule*> {
public:
        CModules();
        ~CModules();

        void SetUser(CUser* pUser) { m_pUser = pUser; }
        void SetNetwork(CIRCNetwork* pNetwork) { m_pNetwork = pNetwork; }
        void SetClient(CClient* pClient) { m_pClient = pClient; }
        CUser* GetUser() { return m_pUser; }
        CIRCNetwork* GetNetwork() { return m_pNetwork; }
        CClient* GetClient() { return m_pClient; }

        void UnloadAll();

        bool OnBoot();
        bool OnPreRehash();
        bool OnPostRehash();
        bool OnIRCDisconnected();
        bool OnIRCConnected();
        bool OnIRCConnecting(CIRCSock *pIRCSock);
        bool OnIRCConnectionError(CIRCSock *pIRCSock);
        bool OnIRCRegistration(CString& sPass, CString& sNick, CString& sIdent, CString& sRealName);
        bool OnBroadcast(CString& sMessage);

        bool OnChanPermission2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, unsigned char uMode, bool bAdded, bool bNoChange);
        bool OnChanPermission(const CNick& OpNick, const CNick& Nick, CChan& Channel, unsigned char uMode, bool bAdded, bool bNoChange);
        bool OnOp2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnOp(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnDeop2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnDeop(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnVoice2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnVoice(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnDevoice2(const CNick* pOpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnDevoice(const CNick& OpNick, const CNick& Nick, CChan& Channel, bool bNoChange);
        bool OnRawMode2(const CNick* pOpNick, CChan& Channel, const CString& sModes, const CString& sArgs);
        bool OnRawMode(const CNick& OpNick, CChan& Channel, const CString& sModes, const CString& sArgs);
        bool OnMode2(const CNick* pOpNick, CChan& Channel, char uMode, const CString& sArg, bool bAdded, bool bNoChange);
        bool OnMode(const CNick& OpNick, CChan& Channel, char uMode, const CString& sArg, bool bAdded, bool bNoChange);

        bool OnRaw(CString& sLine);

        bool OnStatusCommand(CString& sCommand);
        bool OnModCommand(const CString& sCommand);
        bool OnModNotice(const CString& sMessage);
        bool OnModCTCP(const CString& sMessage);

        bool OnQuit(const CNick& Nick, const CString& sMessage, const std::vector<CChan*>& vChans);
        bool OnNick(const CNick& Nick, const CString& sNewNick, const std::vector<CChan*>& vChans);
        bool OnKick(const CNick& Nick, const CString& sOpNick, CChan& Channel, const CString& sMessage);
        bool OnJoin(const CNick& Nick, CChan& Channel);
        bool OnPart(const CNick& Nick, CChan& Channel, const CString& sMessage);
        bool OnInvite(const CNick& Nick, const CString& sChan);

        bool OnChanBufferStarting(CChan& Chan, CClient& Client);
        bool OnChanBufferEnding(CChan& Chan, CClient& Client);
        bool OnChanBufferPlayLine(CChan& Chan, CClient& Client, CString& sLine);
        bool OnPrivBufferPlayLine(CClient& Client, CString& sLine);

        bool OnClientLogin();
        bool OnClientDisconnect();
        bool OnUserRaw(CString& sLine);
        bool OnUserCTCPReply(CString& sTarget, CString& sMessage);
        bool OnUserCTCP(CString& sTarget, CString& sMessage);
        bool OnUserAction(CString& sTarget, CString& sMessage);
        bool OnUserMsg(CString& sTarget, CString& sMessage);
        bool OnUserNotice(CString& sTarget, CString& sMessage);
        bool OnUserJoin(CString& sChannel, CString& sKey);
        bool OnUserPart(CString& sChannel, CString& sMessage);
        bool OnUserTopic(CString& sChannel, CString& sTopic);
        bool OnUserTopicRequest(CString& sChannel);

        bool OnCTCPReply(CNick& Nick, CString& sMessage);
        bool OnPrivCTCP(CNick& Nick, CString& sMessage);
        bool OnChanCTCP(CNick& Nick, CChan& Channel, CString& sMessage);
        bool OnPrivAction(CNick& Nick, CString& sMessage);
        bool OnChanAction(CNick& Nick, CChan& Channel, CString& sMessage);
        bool OnPrivMsg(CNick& Nick, CString& sMessage);
        bool OnChanMsg(CNick& Nick, CChan& Channel, CString& sMessage);
        bool OnPrivNotice(CNick& Nick, CString& sMessage);
        bool OnChanNotice(CNick& Nick, CChan& Channel, CString& sMessage);
        bool OnTopic(CNick& Nick, CChan& Channel, CString& sTopic);
        bool OnTimerAutoJoin(CChan& Channel);

        bool OnAddNetwork(CIRCNetwork& Network, CString& sErrorRet);
        bool OnDeleteNetwork(CIRCNetwork& Network);

        bool OnSendToClient(CString& sLine, CClient& Client);
        bool OnSendToIRC(CString& sLine);

        bool OnServerCapAvailable(const CString& sCap);
        bool OnServerCapResult(const CString& sCap, bool bSuccess);

        CModule* FindModule(const CString& sModule) const;
        bool LoadModule(const CString& sModule, const CString& sArgs, CModInfo::EModuleType eType, CUser* pUser, CIRCNetwork* pNetwork, CString& sRetMsg);
        bool UnloadModule(const CString& sModule);
        bool UnloadModule(const CString& sModule, CString& sRetMsg);
        bool ReloadModule(const CString& sModule, const CString& sArgs, CUser* pUser, CIRCNetwork* pNetwork, CString& sRetMsg);

        static bool GetModInfo(CModInfo& ModInfo, const CString& sModule, CString &sRetMsg);
        static bool GetModPathInfo(CModInfo& ModInfo, const CString& sModule, const CString& sModPath, CString &sRetMsg);
        static void GetAvailableMods(std::set<CModInfo>& ssMods, CModInfo::EModuleType eType = CModInfo::UserModule);

        // This returns the path to the .so and to the data dir
        // which is where static data (webadmin skins) are saved
        static bool FindModPath(const CString& sModule, CString& sModPath,
                        CString& sDataPath);
        // Return a list of <module dir, data dir> pairs for directories in
        // which modules can be found.
        typedef std::queue<std::pair<CString, CString> > ModDirList;
        static ModDirList GetModDirs();

        // Global Modules
        bool OnAddUser(CUser& User, CString& sErrorRet);
        bool OnDeleteUser(CUser& User);
        bool OnClientConnect(CZNCSock* pSock, const CString& sHost, unsigned short uPort);
        bool OnLoginAttempt(CSmartPtr<CAuthBase> Auth);
        bool OnFailedLogin(const CString& sUsername, const CString& sRemoteIP);
        bool OnUnknownUserRaw(CClient* pClient, CString& sLine);
        bool OnClientCapLs(CClient* pClient, SCString& ssCaps);
        bool IsClientCapSupported(CClient* pClient, const CString& sCap, bool bState);
        bool OnClientCapRequest(CClient* pClient, const CString& sCap, bool bState);
        bool OnModuleLoading(const CString& sModName, const CString& sArgs,
                        CModInfo::EModuleType eType, bool& bSuccess, CString& sRetMsg);
        bool OnModuleUnloading(CModule* pModule, bool& bSuccess, CString& sRetMsg);
        bool OnGetModInfo(CModInfo& ModInfo, const CString& sModule,
                        bool& bSuccess, CString& sRetMsg);
        bool OnGetAvailableMods(std::set<CModInfo>& ssMods, CModInfo::EModuleType eType);
        // !Global Modules

private:
        static ModHandle OpenModule(const CString& sModule, const CString& sModPath,
                        bool &bVersionMismatch, CModInfo& Info, CString& sRetMsg);

protected:
        CUser*        m_pUser;
        CIRCNetwork*  m_pNetwork;
        CClient*      m_pClient;
};

#endif // !_MODULES_H