modules.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2020 Matt Schatz <[email protected]>
 *   Copyright (C) 2019 iwalkalone <[email protected]>
 *   Copyright (C) 2013 Adam <[email protected]>
 *   Copyright (C) 2012-2016, 2018 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2013, 2017-2021 Sadie Powell <[email protected]>
 *   Copyright (C) 2012 Robby <[email protected]>
 *   Copyright (C) 2009-2010 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2009 Uli Schlachter <[email protected]>
 *   Copyright (C) 2008 Thomas Stagner <[email protected]>
 *   Copyright (C) 2007-2009 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Oliver Lupton <[email protected]>
 *   Copyright (C) 2006-2007 Dennis Friis <[email protected]>
 *   Copyright (C) 2006 John Brooks <[email protected]>
 *   Copyright (C) 2003-2008, 2010 Craig Edwards <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
#include "moduledefs.h"
#include "dynamic.h"
#include "base.h"
#include "ctables.h"
#include "inspsocket.h"
#include "mode.h"
 
enum ModuleFlags
{
        VF_NONE = 0,
 
        VF_CORE = 1,
 
        /* The module is included with InspIRCd. */
        VF_VENDOR = 2,
 
        VF_COMMON = 4,
 
        VF_OPTCOMMON = 8
};
 
#define MOD_RES_ALLOW (ModResult(1))
 
#define MOD_RES_PASSTHRU (ModResult(0))
 
#define MOD_RES_DENY (ModResult(-1))
 
class ModResult
{
 private:
        char result;
 
 public:
        ModResult()
                : result(0)
        {
        }
 
        explicit ModResult(char res)
                : result(res)
        {
        }
 
        inline bool operator==(const ModResult& res) const
        {
                return result == res.result;
        }
 
        inline bool operator!=(const ModResult& res) const
        {
                return result != res.result;
        }
 
        inline bool operator!() const
        {
                return !result;
        }
 
        inline bool check(bool def) const
        {
                return (result == 1 || (result == 0 && def));
        }
 
        /* Merges two results preferring MOD_RES_ALLOW to MOD_RES_DENY. */
        inline ModResult operator+(const ModResult& res) const
        {
                // If the results are identical or the other result is MOD_RES_PASSTHRU
                // then return this result.
                if (result == res.result || res.result == 0)
                        return *this;
 
                // If this result is MOD_RES_PASSTHRU then return the other result.
                if (result == 0)
                        return res;
 
                // Otherwise, they are different, and neither is MOD_RES_PASSTHRU.
                return MOD_RES_ALLOW;
        }
};
 
#define FOREACH_MOD(y,x) do { \
        const Module::List& _handlers = ServerInstance->Modules->EventHandlers[I_ ## y]; \
        for (Module::List::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
        { \
                _next = _i+1; \
                try \
                { \
                        if (!(*_i)->dying) \
                                (*_i)->y x ; \
                } \
                catch (CoreException& modexcept) \
                { \
                        ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: " + modexcept.GetReason()); \
                } \
        } \
} while (0);
 
#define DO_EACH_HOOK(n,v,args) \
do { \
        const Module::List& _handlers = ServerInstance->Modules->EventHandlers[I_ ## n]; \
        for (Module::List::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
        { \
                _next = _i+1; \
                try \
                { \
                        if (!(*_i)->dying) \
                                v = (*_i)->n args;
 
#define WHILE_EACH_HOOK(n) \
                } \
                catch (CoreException& except_ ## n) \
                { \
                        ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: " + (except_ ## n).GetReason()); \
                } \
        } \
} while(0)
 
#define FIRST_MOD_RESULT(n,v,args) do { \
        v = MOD_RES_PASSTHRU; \
        DO_EACH_HOOK(n,v,args) \
        { \
                if (v != MOD_RES_PASSTHRU) \
                        break; \
        } \
        WHILE_EACH_HOOK(n); \
} while (0)
 
class CoreExport Version
{
 public:
        const std::string description;
 
        const int Flags;
 
        const std::string link_data;
 
        Version(const std::string &desc, int flags = VF_NONE);
 
        Version(const std::string &desc, int flags, const std::string& linkdata);
};
 
class CoreExport DataProvider : public ServiceProvider
{
 public:
        DataProvider(Module* Creator, const std::string& Name)
                : ServiceProvider(Creator, Name, SERVICE_DATA) {}
};
 
enum Priority { PRIORITY_FIRST, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
 
enum Implementation
{
        I_On005Numeric,
        I_OnAcceptConnection,
        I_OnAddLine,
        I_OnBackgroundTimer,
        I_OnBuildNeighborList,
        I_OnChangeHost,
        I_OnChangeIdent,
        I_OnChangeRealHost,
        I_OnChangeRealName,
        I_OnChannelDelete,
        I_OnChannelPreDelete,
        I_OnCheckBan,
        I_OnCheckChannelBan,
        I_OnCheckInvite,
        I_OnCheckKey,
        I_OnCheckLimit,
        I_OnCheckReady,
        I_OnCommandBlocked,
        I_OnConnectionFail,
        I_OnDecodeMetaData,
        I_OnDelLine,
        I_OnExpireLine,
        I_OnExtBanCheck,
        I_OnGarbageCollect,
        I_OnKill,
        I_OnLoadModule,
        I_OnMode,
        I_OnModuleRehash,
        I_OnNumeric,
        I_OnOper,
        I_OnPassCompare,
        I_OnPostChangeRealHost,
        I_OnPostCommand,
        I_OnPostConnect,
        I_OnPostDeoper,
        I_OnPostJoin,
        I_OnPostOper,
        I_OnPostTopicChange,
        I_OnPreChangeHost,
        I_OnPreChangeRealName,
        I_OnPreCommand,
        I_OnPreMode,
        I_OnPreRehash,
        I_OnPreTopicChange,
        I_OnRawMode,
        I_OnSendSnotice,
        I_OnServiceAdd,
        I_OnServiceDel,
        I_OnSetConnectClass,
        I_OnSetUserIP,
        I_OnShutdown,
        I_OnUnloadModule,
        I_OnUserConnect,
        I_OnUserDisconnect,
        I_OnUserInit,
        I_OnUserInvite,
        I_OnUserJoin,
        I_OnUserKick,
        I_OnUserMessage,
        I_OnUserMessageBlocked,
        I_OnUserPart,
        I_OnUserPostInit,
        I_OnUserPostMessage,
        I_OnUserPostNick,
        I_OnUserPreInvite,
        I_OnUserPreJoin,
        I_OnUserPreKick,
        I_OnUserPreMessage,
        I_OnUserPreNick,
        I_OnUserPreQuit,
        I_OnUserQuit,
        I_OnUserRegister,
        I_OnUserWrite,
        I_END
};
 
class CoreExport Module : public classbase, public usecountbase
{
        void DetachEvent(Implementation i);
 
 public:
        typedef std::vector<Module*> List;
 
        std::string ModuleSourceFile;
 
        DLLManager* ModuleDLLManager;
 
        bool dying;
 
        Module();
 
        virtual void init() { }
 
        CullResult cull() CXX11_OVERRIDE;
 
        virtual ~Module();
 
        virtual void Prioritize() { }
 
        virtual void ReadConfig(ConfigStatus& status);
 
        virtual Version GetVersion() = 0;
 
        virtual void OnUserConnect(LocalUser* user);
 
        virtual ModResult OnUserPreQuit(LocalUser* user, std::string& message, std::string& oper_message);
 
        virtual void OnUserQuit(User* user, const std::string &message, const std::string &oper_message);
 
        virtual void OnUserDisconnect(LocalUser* user);
 
        virtual ModResult OnChannelPreDelete(Channel *chan);
 
        virtual void OnChannelDelete(Channel* chan);
 
        virtual void OnUserJoin(Membership* memb, bool sync, bool created, CUList& except_list);
 
        virtual void OnPostJoin(Membership* memb);
 
        virtual void OnUserPart(Membership* memb, std::string &partmessage, CUList& except_list);
 
        virtual void OnPreRehash(User* user, const std::string &parameter);
 
        virtual void OnModuleRehash(User* user, const std::string &parameter);
 
        virtual ModResult OnSendSnotice(char &snomask, std::string &type, const std::string &message);
 
        virtual ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven);
 
        virtual ModResult OnUserPreKick(User* source, Membership* memb, const std::string &reason);
 
        virtual void OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& except_list);
 
        virtual void OnOper(User* user, const std::string &opertype);
 
        virtual void OnPostOper(User* user, const std::string &opername, const std::string &opertype);
 
        virtual void OnPostDeoper(User* user);
 
        virtual ModResult OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout);
 
        virtual void OnUserInvite(User* source, User* dest, Channel* channel, time_t timeout, unsigned int notifyrank, CUList& notifyexcepts);
 
        virtual ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details);
 
        virtual void OnBuildNeighborList(User* source, IncludeChanList& include_c, std::map<User*, bool>& exceptions);
 
        virtual ModResult OnUserPreNick(LocalUser* user, const std::string& newnick);
 
        virtual void OnUserPostMessage(User* user, const MessageTarget& target, const MessageDetails& details);
 
        virtual void OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details);
 
        virtual void OnUserMessageBlocked(User* user, const MessageTarget& target, const MessageDetails& details);
 
        virtual void OnMode(User* user, User* usertarget, Channel* chantarget, const Modes::ChangeList& changelist, ModeParser::ModeProcessFlag processflags);
 
        virtual void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata);
 
        virtual void OnChangeHost(User* user, const std::string &newhost);
 
        virtual void OnChangeRealHost(User* user, const std::string& newhost);
 
        virtual void OnPostChangeRealHost(User* user);
 
        virtual void OnChangeRealName(User* user, const std::string& real);
 
        virtual void OnChangeIdent(User* user, const std::string &ident);
 
        virtual void OnAddLine(User* source, XLine* line);
 
        virtual void OnDelLine(User* source, XLine* line);
 
        virtual void OnExpireLine(XLine *line);
 
        virtual void OnCleanup(ExtensionItem::ExtensibleType type, Extensible* item);
 
        virtual void OnUserPostNick(User* user, const std::string &oldnick);
 
        virtual ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes);
 
        virtual void On005Numeric(std::map<std::string, std::string>& tokens);
 
        virtual ModResult OnKill(User* source, User* dest, const std::string &reason);
 
        virtual void OnLoadModule(Module* mod);
 
        virtual void OnUnloadModule(Module* mod);
 
        virtual void OnBackgroundTimer(time_t curtime);
 
        virtual ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated);
 
        virtual void OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, bool loop);
 
        virtual void OnCommandBlocked(const std::string& command, const CommandBase::Params& parameters, LocalUser* user);
 
        virtual void OnUserInit(LocalUser* user);
 
        virtual void OnUserPostInit(LocalUser* user);
 
        virtual ModResult OnCheckReady(LocalUser* user);
 
        virtual ModResult OnUserRegister(LocalUser* user);
 
        virtual ModResult OnCheckInvite(User* user, Channel* chan);
 
        virtual ModResult OnRawMode(User* user, Channel* chan, ModeHandler* mh, const std::string& param, bool adding);
 
        virtual ModResult OnCheckKey(User* user, Channel* chan, const std::string &keygiven);
 
        virtual ModResult OnCheckLimit(User* user, Channel* chan);
 
        virtual ModResult OnCheckChannelBan(User* user, Channel* chan);
 
        virtual ModResult OnCheckBan(User* user, Channel* chan, const std::string& mask);
 
        virtual ModResult OnExtBanCheck(User* user, Channel* chan, char type);
 
        virtual ModResult OnPreChangeHost(LocalUser* user, const std::string &newhost);
 
        virtual ModResult OnPreChangeRealName(LocalUser* user, const std::string &newhost);
 
        virtual ModResult OnPreTopicChange(User* user, Channel* chan, const std::string &topic);
 
        virtual void OnPostTopicChange(User* user, Channel* chan, const std::string &topic);
 
        virtual ModResult OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype);
 
        virtual void OnPostConnect(User* user);
 
        virtual ModResult OnAcceptConnection(int fd, ListenSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
 
        virtual void OnGarbageCollect();
 
        virtual ModResult OnSetConnectClass(LocalUser* user, ConnectClass* myclass);
 
        virtual ModResult OnNumeric(User* user, const Numeric::Numeric& numeric);
 
        virtual void OnSetUserIP(LocalUser* user);
 
        virtual void OnServiceAdd(ServiceProvider& service);
 
        virtual void OnServiceDel(ServiceProvider& service);
 
        virtual ModResult OnUserWrite(LocalUser* user, ClientProtocol::Message& msg);
 
        virtual ModResult OnConnectionFail(LocalUser* user, BufferedSocketError error);
 
        virtual void OnShutdown(const std::string& reason);
};
 
class CoreExport ModuleManager : public fakederef<ModuleManager>
{
 public:
        typedef std::multimap<std::string, ServiceProvider*, irc::insensitive_swo> DataProviderMap;
        typedef std::vector<ServiceProvider*> ServiceList;
 
 private:
        std::string LastModuleError;
 
        std::map<std::string, Module*> Modules;
 
        enum {
                PRIO_STATE_FIRST,
                PRIO_STATE_AGAIN,
                PRIO_STATE_LAST
        } prioritizationState;
 
        void LoadCoreModules(std::map<std::string, ServiceList>& servicemap);
 
        bool PrioritizeHooks();
 
        void UnregisterModes(Module* mod, ModeType modetype);
 
 public:
        typedef std::map<std::string, Module*> ModuleMap;
 
        Module::List EventHandlers[I_END];
 
        DataProviderMap DataProviders;
 
        ServiceList* NewServices;
 
        static std::string ExpandModName(const std::string& modname);
 
        ModuleManager();
 
        ~ModuleManager();
 
        bool SetPriority(Module* mod, Implementation i, Priority s, Module* which = NULL);
 
        void SetPriority(Module* mod, Priority 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);
 
        void AttachAll(Module* mod);
 
        std::string& LastError();
 
        bool Load(const std::string& filename, bool defer = false);
 
        bool Unload(Module* module);
 
        void LoadAll();
        void UnloadAll();
        void DoSafeUnload(Module*);
 
        bool CanUnload(Module* mod);
 
        Module* Find(const std::string &name);
 
        void AddService(ServiceProvider&);
 
        void DelService(ServiceProvider&);
 
        void AddServices(const ServiceList& list);
 
        inline void AddServices(ServiceProvider** list, int count)
        {
                for(int i=0; i < count; i++)
                        AddService(*list[i]);
        }
 
        ServiceProvider* FindService(ServiceType Type, const std::string& name);
 
        template<typename T> inline T* FindDataService(const std::string& name)
        {
                return static_cast<T*>(FindService(SERVICE_DATA, name));
        }
 
        const ModuleMap& GetModules() const { return Modules; }
 
        void AddReferent(const std::string& name, ServiceProvider* service);
 
        void DelReferent(ServiceProvider* service);
};