Modules.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2025 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 ZNC_MODULES_H
#define ZNC_MODULES_H
 
#include <znc/zncconfig.h>
#include <znc/WebModules.h>
#include <znc/Utils.h>
#include <znc/Threads.h>
#include <znc/Message.h>
#include <znc/main.h>
#include <znc/Translation.h>
#include <functional>
#include <memory>
#include <set>
#include <queue>
#include <sys/time.h>
 
// Forward Declarations
class CAuthBase;
class CChan;
class CQuery;
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
 
#ifdef BUILD_WITH_CMAKE
#include <znc/znc_export_lib_export.h>
#elif HAVE_VISIBILITY
#define ZNC_EXPORT_LIB_EXPORT __attribute__((__visibility__("default")))
#else
#define ZNC_EXPORT_LIB_EXPORT
#endif

struct CModuleEntry {
    const char* pcVersion;
    const char* pcVersionExtra;
    const char* pcCompileOptions;
    void (*fpFillModInfo)(CModInfo&);
};
 
#define MODCOMMONDEFS(CLASS, DESCRIPTION, TYPE)                             \
    static void FillModInfo(CModInfo& Info) {                               \
        auto t_s = [&](const CString& sEnglish,                             \
                       const CString& sContext = "") {                      \
            return sEnglish.empty() ? "" : Info.t_s(sEnglish, sContext);    \
        };                                                                  \
        t_s(CString()); /* Don't warn about unused t_s */                   \
        Info.SetDescription(DESCRIPTION);                                   \
        Info.SetDefaultType(TYPE);                                          \
        Info.AddType(TYPE);                                                 \
        Info.SetLoader(TModLoad<CLASS>);                                    \
        TModInfo<CLASS>(Info);                                              \
    }                                                                       \
    extern "C" {                                                            \
    /* A global variable leads to ODR violation when several modules are    \
     * loaded. But a static variable inside a function works. */            \
    ZNC_EXPORT_LIB_EXPORT const CModuleEntry* ZNCModuleEntry();             \
    ZNC_EXPORT_LIB_EXPORT const CModuleEntry* ZNCModuleEntry() {            \
        static const CModuleEntry ThisModule = {VERSION_STR, VERSION_EXTRA, \
                                                ZNC_COMPILE_OPTIONS_STRING, \
                                                FillModInfo};               \
        return &ThisModule;                                                 \
    }                                                                       \
    }

#define MODCONSTRUCTOR(CLASS)                                  \
    CLASS(ModHandle pDLL, CUser* pUser, CIRCNetwork* pNetwork, \
          const CString& sModName, const CString& sModPath,    \
          CModInfo::EModuleType eType)                         \
        : CModule(pDLL, pUser, pNetwork, sModName, sModPath, eType)
 
// 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 CCapability {
  public:
    virtual ~CCapability() = default;
    virtual void OnServerChangedSupport(CIRCNetwork* pNetwork, bool bState) {}
    virtual void OnClientChangedSupport(CClient* pClient, bool bState) {}
 
    CModule* GetModule() { return m_pModule; }
    void SetModule(CModule* p) { m_pModule = p; }
 
  protected:
    CModule* m_pModule = nullptr;
};
 
class CTimer : public CCron {
  public:
    CTimer(CModule* pModule, unsigned int uInterval, unsigned int uCycles,
           const CString& sLabel, const CString& sDescription);
 
    virtual ~CTimer();
 
    CTimer(const CTimer&) = delete;
    CTimer& operator=(const CTimer&) = delete;
 
    // 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(nullptr) {}
 
    virtual ~CFPTimer() {}
 
    void SetFPCallback(FPTimer_t p) { m_pFBCallback = p; }
 
  protected:
    void RunJob() override {
        if (m_pFBCallback) {
            m_pFBCallback(m_pModule, this);
        }
    }
 
  private:
    FPTimer_t m_pFBCallback;
};
 
#ifdef HAVE_PTHREAD
class CModuleJob : public CJob {
  public:
    CModuleJob(CModule* pModule, const CString& sName, const CString& sDesc)
        : CJob(), m_pModule(pModule), m_sName(sName), m_sDescription(sDesc) {}
    virtual ~CModuleJob();
 
    CModuleJob(const CModuleJob&) = delete;
    CModuleJob& operator=(const CModuleJob&) = delete;
 
    // Getters
    CModule* GetModule() const { return m_pModule; }
    const CString& GetName() const { return m_sName; }
    const CString& GetDescription() const { return m_sDescription; }
    // !Getters
 
  protected:
    CModule* m_pModule;
    const CString m_sName;
    const CString m_sDescription;
};
#endif
 
typedef void* ModHandle;
 
class CModInfo {
  public:
    typedef enum { GlobalModule, UserModule, NetworkModule } EModuleType;
 
    typedef CModule* (*ModLoader)(ModHandle p, CUser* pUser,
                                  CIRCNetwork* pNetwork,
                                  const CString& sModName,
                                  const CString& sModPath, EModuleType eType);
 
    CModInfo() : CModInfo("", "", NetworkModule) {}
    CModInfo(const CString& sName, const CString& sPath, EModuleType eType)
        : m_seType(),
          m_eDefaultType(eType),
          m_sName(sName),
          m_sPath(sPath),
          m_sDescription(""),
          m_sWikiPage(""),
          m_sArgsHelpText(""),
          m_bHasArgs(false),
          m_fLoader(nullptr) {}
    ~CModInfo() {}
 
    bool operator<(const CModInfo& Info) const {
        return (GetName() < Info.GetName());
    }
 
    bool SupportsType(EModuleType eType) const {
        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
 
    CString t_s(const CString& sEnglish, const CString& sContext = "") const;
 
  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;
};
 
template <class M>
void TModInfo(CModInfo& Info) {}
 
template <class M>
CModule* TModLoad(ModHandle p, CUser* pUser, CIRCNetwork* pNetwork,
                  const CString& sModName, const CString& sModPath,
                  CModInfo::EModuleType eType) {
    return new M(p, pUser, pNetwork, sModName, sModPath, eType);
}

class CModCommand : private CCoreTranslationMixin {
  public:
    typedef void (CModule::*ModCmdFunc)(const CString& sLine);
    typedef std::function<void(const CString& sLine)> CmdFunc;

    CModCommand();

    CModCommand(const CString& sCmd, CModule* pMod, ModCmdFunc func,
                const CString& sArgs, const CString& sDesc);
    CModCommand(const CString& sCmd, CmdFunc func,
                const COptionalTranslation& Args,
                const COptionalTranslation& Desc);

    CModCommand(const CModCommand& other) = default;

    CModCommand& operator=(const CModCommand& other) = default;

    static void InitHelp(CTable& Table);

    void AddHelp(CTable& Table) const;
 
    const CString& GetCommand() const { return m_sCmd; }
    CmdFunc GetFunction() const { return m_pFunc; }
    CString GetArgs() const { return m_Args.Resolve(); }
    CString GetDescription() const { return m_Desc.Resolve(); }
 
    void Call(const CString& sLine) const { m_pFunc(sLine); }
 
  private:
    CString m_sCmd;
    CmdFunc m_pFunc;
    COptionalTranslation m_Args;
    COptionalTranslation m_Desc;
};

class CModule {
  public:
    CModule(
        ModHandle pDLL, CUser* pUser, CIRCNetwork* pNetwork,
        const CString& sModName, const CString& sDataDir,
        CModInfo::EModuleType eType =
            CModInfo::NetworkModule);  // TODO: remove default value in ZNC 2.x
    virtual ~CModule();
 
    CModule(const CModule&) = delete;
    CModule& operator=(const CModule&) = delete;

    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);

    bool IsCallStackEmpty() const;

    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 bool ValidateWebRequestCSRFCheck(CWebSock& WebSock, const CString& sPageName);
    virtual void AddSubPage(TWebSubPage spSubPage) {
        m_vSubPages.push_back(spSubPage);
    }

    virtual void ClearSubPages() { m_vSubPages.clear(); }
    virtual VWebSubPages& GetSubPages() { return m_vSubPages; }
  private:
    virtual bool OnEmbeddedWebRequest(CWebSock& WebSock,
                                      const CString& sPageName,
                                      CTemplate& Tmpl);
  public:
    bool DoEmbeddedWebRequest(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 OnChanPermission3(const CNick* pOpNick, const CNick& Nick,
                                   CChan& Channel, char cMode,
                                   bool bAdded, bool bNoChange);
    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 OnRawMessage(CMessage& Message);

    virtual EModRet OnNumericMessage(CNumericMessage& Message);

    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 OnQuitMessage(CQuitMessage& Message,
                               const std::vector<CChan*>& vChans);
    virtual void OnQuit(const CNick& Nick, const CString& sMessage,
                        const std::vector<CChan*>& vChans);

    virtual void OnNickMessage(CNickMessage& Message,
                               const std::vector<CChan*>& vChans);
    virtual void OnNick(const CNick& Nick, const CString& sNewNick,
                        const std::vector<CChan*>& vChans);

    virtual void OnKickMessage(CKickMessage& Message);
    virtual void OnKick(const CNick& OpNick, const CString& sKickedNick,
                        CChan& Channel, const CString& sMessage);

    virtual EModRet OnJoining(CChan& Channel);

    virtual void OnJoinMessage(CJoinMessage& Message);
    virtual void OnJoin(const CNick& Nick, CChan& Channel);

    virtual void OnPartMessage(CPartMessage& Message);
    virtual void OnPart(const CNick& Nick, CChan& Channel,
                        const CString& sMessage);

    virtual EModRet OnInviteMessage(CInviteMessage& Message);
    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 OnChanBufferPlayMessage(CMessage& Message);
    virtual EModRet OnChanBufferPlayLine2(CChan& Chan, CClient& Client,
                                          CString& sLine, const timeval& tv);
    virtual EModRet OnChanBufferPlayLine(CChan& Chan, CClient& Client,
                                         CString& sLine);

    virtual EModRet OnPrivBufferStarting(CQuery& Query, CClient& Client);
    virtual EModRet OnPrivBufferEnding(CQuery& Query, CClient& Client);

    virtual EModRet OnPrivBufferPlayMessage(CMessage& Message);
    virtual EModRet OnPrivBufferPlayLine2(CClient& Client, CString& sLine,
                                          const timeval& tv);
    virtual EModRet OnPrivBufferPlayLine(CClient& Client, CString& sLine);

    virtual void OnClientLogin();
    virtual void OnClientDisconnect();

    virtual EModRet OnUserRaw(CString& sLine);
    virtual EModRet OnUserRawMessage(CMessage& Message);

    virtual EModRet OnUserCTCPReplyMessage(CCTCPMessage& Message);
    virtual EModRet OnUserCTCPReply(CString& sTarget, CString& sMessage);

    virtual EModRet OnUserCTCPMessage(CCTCPMessage& Message);
    virtual EModRet OnUserCTCP(CString& sTarget, CString& sMessage);

    virtual EModRet OnUserActionMessage(CActionMessage& Message);
    virtual EModRet OnUserAction(CString& sTarget, CString& sMessage);

    virtual EModRet OnUserTextMessage(CTextMessage& Message);
    virtual EModRet OnUserMsg(CString& sTarget, CString& sMessage);

    virtual EModRet OnUserNoticeMessage(CNoticeMessage& Message);
    virtual EModRet OnUserNotice(CString& sTarget, CString& sMessage);

    virtual EModRet OnUserJoinMessage(CJoinMessage& Message);
    virtual EModRet OnUserJoin(CString& sChannel, CString& sKey);

    virtual EModRet OnUserPartMessage(CPartMessage& Message);
    virtual EModRet OnUserPart(CString& sChannel, CString& sMessage);

    virtual EModRet OnUserTopicMessage(CTopicMessage& Message);
    virtual EModRet OnUserTopic(CString& sChannel, CString& sTopic);

    virtual EModRet OnUserTopicRequest(CString& sChannel);

    virtual EModRet OnUserQuitMessage(CQuitMessage& Message);
    virtual EModRet OnUserQuit(CString& sMessage);

    virtual EModRet OnCTCPReplyMessage(CCTCPMessage& Message);
    virtual EModRet OnCTCPReply(CNick& Nick, CString& sMessage);

    virtual EModRet OnPrivCTCPMessage(CCTCPMessage& Message);
    virtual EModRet OnPrivCTCP(CNick& Nick, CString& sMessage);

    virtual EModRet OnChanCTCPMessage(CCTCPMessage& Message);
    virtual EModRet OnChanCTCP(CNick& Nick, CChan& Channel, CString& sMessage);

    virtual EModRet OnPrivActionMessage(CActionMessage& Message);
    virtual EModRet OnPrivAction(CNick& Nick, CString& sMessage);

    virtual EModRet OnChanActionMessage(CActionMessage& Message);
    virtual EModRet OnChanAction(CNick& Nick, CChan& Channel,
                                 CString& sMessage);

    virtual EModRet OnPrivTextMessage(CTextMessage& Message);
    virtual EModRet OnPrivMsg(CNick& Nick, CString& sMessage);

    virtual EModRet OnChanTextMessage(CTextMessage& Message);
    virtual EModRet OnChanMsg(CNick& Nick, CChan& Channel, CString& sMessage);

    virtual EModRet OnPrivNoticeMessage(CNoticeMessage& Message);
    virtual EModRet OnPrivNotice(CNick& Nick, CString& sMessage);

    virtual EModRet OnChanNoticeMessage(CNoticeMessage& Message);
    virtual EModRet OnChanNotice(CNick& Nick, CChan& Channel,
                                 CString& sMessage);

    virtual EModRet OnTopicMessage(CTopicMessage& Message);
    virtual EModRet OnTopic(CNick& Nick, CChan& Channel, CString& sTopic);

    virtual bool OnServerCapAvailable(const CString& sCap);
    virtual bool OnServerCap302Available(const CString& sCap, const CString& sValue);
    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 OnSendToClientMessage(CMessage& Message);
    virtual EModRet OnSendToClient(CString& sLine, CClient& Client);

    virtual EModRet OnSendToIRCMessage(CMessage& Message);
    virtual EModRet OnSendToIRC(CString& sLine);

    virtual EModRet OnUserTagMessage(CTargetMessage& Message);
    virtual EModRet OnChanTagMessage(CTargetMessage& Message);
    virtual EModRet OnPrivTagMessage(CTargetMessage& Message);
 
    ModHandle GetDLL() { return m_pDLL; }

    virtual bool PutIRC(const CString& sLine);
    virtual bool PutIRC(const CMessage& Message);
    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
 
#ifdef HAVE_PTHREAD
    // Job stuff
    void AddJob(CModuleJob* pJob);
    void CancelJob(CModuleJob* pJob);
    bool CancelJob(const CString& sJobName);
    void CancelJobs(const std::set<CModuleJob*>& sJobs);
    bool UnlinkJob(CModuleJob* pJob);
// !Job stuff
#endif
 
    // Command stuff
    void AddHelpCommand();
    bool AddCommand(const CModCommand& Command);
    bool AddCommand(const CString& sCmd, CModCommand::ModCmdFunc func,
                    const CString& sArgs = "", const CString& sDesc = "");
    bool AddCommand(const CString& sCmd, const COptionalTranslation& Args,
                    const COptionalTranslation& Desc,
                    std::function<void(const CString& sLine)> func);
    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 MoveRegistry(const CString& sPath);
    bool SetNV(const CString& sName, const CString& sValue,
               bool bWriteToDisk = true);
    CString GetNV(const CString& sName) const;
    bool HasNV(const CString& sName) const {
        return m_mssRegistry.find(sName) != m_mssRegistry.end();
    }
    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() const { return m_pUser; }
    CIRCNetwork* GetNetwork() const { return m_pNetwork; }
    CClient* GetClient() const { return m_pClient; }
    CSockManager* GetManager() const { 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(std::shared_ptr<CAuthBase> Auth);
    virtual void OnFailedLogin(const CString& sUsername,
                               const CString& sRemoteIP);
    virtual EModRet OnUnknownUserRaw(CClient* pClient, CString& sLine);
    virtual EModRet OnUnknownUserRawMessage(CMessage& Message);

    virtual void OnClientAttached();
    virtual void OnClientDetached();
 
#ifndef SWIG
    void AddServerDependentCapability(const CString& sName, std::unique_ptr<CCapability> pCap);
#endif

    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 void OnClientGetSASLMechanisms(SCString& ssMechanisms);
    virtual EModRet OnClientSASLServerInitialChallenge(
        const CString& sMechanism, CString& sResponse);
    virtual EModRet OnClientSASLAuthenticate(const CString& sMechanism,
                                             const CString& sMessage);
    virtual void OnClientSASLAborted();

    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
 
#ifndef SWIG
    // Translation
    CString t_s(const CString& sEnglish, const CString& sContext = "") const;
    CInlineFormatMessage t_f(const CString& sEnglish,
                             const CString& sContext = "") const;
    CInlineFormatMessage t_p(const CString& sEnglish, const CString& sEnglishes,
                             int iNum, const CString& sContext = "") const;
    CDelayedTranslation t_d(const CString& sEnglish,
                            const CString& sContext = "") const;
#endif
 
    // Default implementations of several callbacks to make
    // AddServerDependentCapability work in modpython/modperl.
    // Don't worry about existence of these functions.
    bool InternalServerDependentCapsOnServerCap302Available(
        const CString& sCap, const CString& sValue);
    void InternalServerDependentCapsOnServerCapResult(const CString& sCap,
                                                      bool bSuccess);
    void InternalServerDependentCapsOnClientCapLs(CClient* pClient,
                                                  SCString& ssCaps);
    bool InternalServerDependentCapsIsClientCapSupported(CClient* pClient,
                                                         const CString& sCap,
                                                         bool bState);
    void InternalServerDependentCapsOnClientCapRequest(CClient* pClient,
                                                       const CString& sCap,
                                                       bool bState);
    void InternalServerDependentCapsOnClientAttached();
    void InternalServerDependentCapsOnClientDetached();
    void InternalServerDependentCapsOnIRCConnected();
    void InternalServerDependentCapsOnIRCDisconnected();
 
  protected:
    CModInfo::EModuleType m_eType;
    CString m_sDescription;
    std::set<CTimer*> m_sTimers;
    std::set<CSocket*> m_sSockets;
#ifdef HAVE_PTHREAD
    std::set<CModuleJob*> m_sJobs;
#endif
    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;
    CTranslationDomainRefHolder m_Translation;
    std::map<CString, std::unique_ptr<CCapability>> m_mServerDependentCaps;
 
  private:
    MCString
        m_mssRegistry;  
    VWebSubPages m_vSubPages;
    std::map<CString, CModCommand> m_mCommands;
    int m_iCallStackDepth = 0;
 
    friend struct CModCallProtector;
};
 
class CModules : public std::vector<CModule*>, private CCoreTranslationMixin {
  public:
    CModules();
    ~CModules();
 
    CModules(const CModules&) = default;
    CModules& operator=(const CModules&) = default;
 
    void SetUser(CUser* pUser) { m_pUser = pUser; }
    void SetNetwork(CIRCNetwork* pNetwork) { m_pNetwork = pNetwork; }
    void SetClient(CClient* pClient) { m_pClient = pClient; }
    CUser* GetUser() const { return m_pUser; }
    CIRCNetwork* GetNetwork() const { return m_pNetwork; }
    CClient* GetClient() const { 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 OnChanPermission3(const CNick* pOpNick, const CNick& Nick,
                           CChan& Channel, char cMode, bool bAdded,
                           bool bNoChange);
    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 OnRawMessage(CMessage& Message);
    bool OnNumericMessage(CNumericMessage& Message);
 
    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 OnQuitMessage(CQuitMessage& Message,
                       const std::vector<CChan*>& vChans);
    bool OnNick(const CNick& Nick, const CString& sNewNick,
                const std::vector<CChan*>& vChans);
    bool OnNickMessage(CNickMessage& Message,
                       const std::vector<CChan*>& vChans);
    bool OnKick(const CNick& Nick, const CString& sOpNick, CChan& Channel,
                const CString& sMessage);
    bool OnKickMessage(CKickMessage& Message);
    bool OnJoining(CChan& Channel);
    bool OnJoin(const CNick& Nick, CChan& Channel);
    bool OnJoinMessage(CJoinMessage& Message);
    bool OnPart(const CNick& Nick, CChan& Channel, const CString& sMessage);
    bool OnPartMessage(CPartMessage& Message);
    bool OnInvite(const CNick& Nick, const CString& sChan);
    bool OnInviteMessage(CInviteMessage& Message);
 
    bool OnChanBufferStarting(CChan& Chan, CClient& Client);
    bool OnChanBufferEnding(CChan& Chan, CClient& Client);
    bool OnChanBufferPlayLine2(CChan& Chan, CClient& Client, CString& sLine,
                               const timeval& tv);
    bool OnChanBufferPlayLine(CChan& Chan, CClient& Client, CString& sLine);
    bool OnPrivBufferStarting(CQuery& Query, CClient& Client);
    bool OnPrivBufferEnding(CQuery& Query, CClient& Client);
    bool OnPrivBufferPlayLine2(CClient& Client, CString& sLine,
                               const timeval& tv);
    bool OnPrivBufferPlayLine(CClient& Client, CString& sLine);
    bool OnChanBufferPlayMessage(CMessage& Message);
    bool OnPrivBufferPlayMessage(CMessage& Message);
 
    bool OnClientLogin();
    bool OnClientDisconnect();
    bool OnUserRaw(CString& sLine);
    bool OnUserRawMessage(CMessage& Message);
    bool OnUserCTCPReply(CString& sTarget, CString& sMessage);
    bool OnUserCTCPReplyMessage(CCTCPMessage& Message);
    bool OnUserCTCP(CString& sTarget, CString& sMessage);
    bool OnUserCTCPMessage(CCTCPMessage& Message);
    bool OnUserAction(CString& sTarget, CString& sMessage);
    bool OnUserActionMessage(CActionMessage& Message);
    bool OnUserMsg(CString& sTarget, CString& sMessage);
    bool OnUserTextMessage(CTextMessage& Message);
    bool OnUserNotice(CString& sTarget, CString& sMessage);
    bool OnUserNoticeMessage(CNoticeMessage& Message);
    bool OnUserJoin(CString& sChannel, CString& sKey);
    bool OnUserJoinMessage(CJoinMessage& Message);
    bool OnUserPart(CString& sChannel, CString& sMessage);
    bool OnUserPartMessage(CPartMessage& Message);
    bool OnUserTopic(CString& sChannel, CString& sTopic);
    bool OnUserTopicMessage(CTopicMessage& Message);
    bool OnUserTopicRequest(CString& sChannel);
    bool OnUserQuit(CString& sMessage);
    bool OnUserQuitMessage(CQuitMessage& Message);
    bool OnUserTagMessage(CTargetMessage& Message);
    bool OnChanTagMessage(CTargetMessage& Message);
    bool OnPrivTagMessage(CTargetMessage& Message);
 
    bool OnCTCPReply(CNick& Nick, CString& sMessage);
    bool OnCTCPReplyMessage(CCTCPMessage& Message);
    bool OnPrivCTCP(CNick& Nick, CString& sMessage);
    bool OnPrivCTCPMessage(CCTCPMessage& Message);
    bool OnChanCTCP(CNick& Nick, CChan& Channel, CString& sMessage);
    bool OnChanCTCPMessage(CCTCPMessage& Message);
    bool OnPrivAction(CNick& Nick, CString& sMessage);
    bool OnPrivActionMessage(CActionMessage& Message);
    bool OnChanAction(CNick& Nick, CChan& Channel, CString& sMessage);
    bool OnChanActionMessage(CActionMessage& Message);
    bool OnPrivMsg(CNick& Nick, CString& sMessage);
    bool OnPrivTextMessage(CTextMessage& Message);
    bool OnChanMsg(CNick& Nick, CChan& Channel, CString& sMessage);
    bool OnChanTextMessage(CTextMessage& Message);
    bool OnPrivNotice(CNick& Nick, CString& sMessage);
    bool OnPrivNoticeMessage(CNoticeMessage& Message);
    bool OnChanNotice(CNick& Nick, CChan& Channel, CString& sMessage);
    bool OnChanNoticeMessage(CNoticeMessage& Message);
    bool OnTopic(CNick& Nick, CChan& Channel, CString& sTopic);
    bool OnTopicMessage(CTopicMessage& Message);
    bool OnTimerAutoJoin(CChan& Channel);
 
    bool OnAddNetwork(CIRCNetwork& Network, CString& sErrorRet);
    bool OnDeleteNetwork(CIRCNetwork& Network);
 
    bool OnSendToClient(CString& sLine, CClient& Client);
    bool OnSendToClientMessage(CMessage& Message);
    bool OnSendToIRC(CString& sLine);
    bool OnSendToIRCMessage(CMessage& Message);
    bool OnClientAttached();
    bool OnClientDetached();
 
    bool OnServerCapAvailable(const CString& sCap, const CString& sValue);
    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);
    static void GetDefaultMods(
        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(std::shared_ptr<CAuthBase> Auth);
    bool OnFailedLogin(const CString& sUsername, const CString& sRemoteIP);
    bool OnUnknownUserRaw(CClient* pClient, CString& sLine);
    bool OnUnknownUserRawMessage(CMessage& Message);
    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 OnClientGetSASLMechanisms(SCString& ssMechanisms);
    bool OnClientSASLAborted();
    bool OnClientSASLServerInitialChallenge(const CString& sMechanism,
                                            CString& sResponse);
    bool OnClientSASLAuthenticate(const CString& sMechanism,
                                  const CString& sBuffer);
 
    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,
                                CModInfo& Info, CString& sRetMsg);
    static bool ValidateModuleName(const CString& sModule, CString& sRetMsg);
 
  protected:
    CUser* m_pUser;
    CIRCNetwork* m_pNetwork;
    CClient* m_pClient;
};
 
struct CModCallProtector {
    explicit CModCallProtector(CModule& pMod) : m_pMod(&pMod) {
        pMod.m_iCallStackDepth++;
    }
    ~CModCallProtector() { m_pMod->m_iCallStackDepth--; }
 
    CModule* m_pMod;
};
 
#ifndef SWIG
template <typename T, T* (CModule::*Getter)() const, void (CModule::*Setter)(T*)>
struct CTemporaryModField {
    CTemporaryModField(CModule& pMod, T* pValue) {
        m_pMod = &pMod;
        m_pOldT = (pMod.*Getter)();
        if (pValue) {
            (pMod.*Setter)(pValue);
        }
    }
 
    ~CTemporaryModField() { (m_pMod->*Setter)(m_pOldT); }
 
    CModule* m_pMod;
    T* m_pOldT;
};
 
using CTemporaryModClient =
    CTemporaryModField<CClient, &CModule::GetClient, &CModule::SetClient>;
using CTemporaryModNetwork =
    CTemporaryModField<CIRCNetwork, &CModule::GetNetwork, &CModule::SetNetwork>;
using CTemporaryModUser =
    CTemporaryModField<CUser, &CModule::GetUser, &CModule::SetUser>;
 
// Same as above, but for plural CModules
template <typename T, T* (CModules::*Getter)() const, void (CModules::*Setter)(T*)>
struct CTemporaryModsField {
    CTemporaryModsField(CModules& pMods, T* pValue) {
        m_pMods = &pMods;
        m_pOldT = (pMods.*Getter)();
        if (pValue) {
            (pMods.*Setter)(pValue);
        }
    }
 
    ~CTemporaryModsField() { (m_pMods->*Setter)(m_pOldT); }
 
    CModules* m_pMods;
    T* m_pOldT;
};
 
using CTemporaryModsClient =
    CTemporaryModsField<CClient, &CModules::GetClient, &CModules::SetClient>;
using CTemporaryModsNetwork =
    CTemporaryModsField<CIRCNetwork, &CModules::GetNetwork, &CModules::SetNetwork>;
using CTemporaryModsUser =
    CTemporaryModsField<CUser, &CModules::GetUser, &CModules::SetUser>;
#endif
 
#endif  // !ZNC_MODULES_H