From 259b1113944a01aeb450265f03fb97a283e8ef15 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:29:01 +0100 Subject: Add rewritten m_cap module - Caps are now managed by m_cap - Each cap uses one bit in an extension item shared with other caps --- src/modules/m_cap.cpp | 245 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 src/modules/m_cap.cpp (limited to 'src/modules/m_cap.cpp') diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp new file mode 100644 index 000000000..9e857ad28 --- /dev/null +++ b/src/modules/m_cap.cpp @@ -0,0 +1,245 @@ +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2015 Attila Molnar + * + * 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 . + */ + + +#include "inspircd.h" +#include "modules/cap.h" + +namespace Cap +{ + class ManagerImpl; +} + +class Cap::ManagerImpl : public Cap::Manager +{ + typedef insp::flat_map CapMap; + + ExtItem capext; + CapMap caps; + + Capability::Bit AllocateBit() const + { + Capability::Bit used = 0; + for (CapMap::const_iterator i = caps.begin(); i != caps.end(); ++i) + { + Capability* cap = i->second; + used |= cap->GetMask(); + } + + for (unsigned int i = 0; i < MAX_CAPS; i++) + { + Capability::Bit bit = (1 << i); + if (!(used & bit)) + return bit; + } + throw ModuleException("Too many caps"); + } + + public: + ManagerImpl(Module* mod) + : Cap::Manager(mod) + , capext("caps", ExtensionItem::EXT_USER, mod) + { + } + + ~ManagerImpl() + { + for (CapMap::iterator i = caps.begin(); i != caps.end(); ++i) + { + Capability* cap = i->second; + cap->Unregister(); + } + } + + void AddCap(Cap::Capability* cap) CXX11_OVERRIDE + { + // No-op if the cap is already registered. + // This allows modules to call SetActive() on a cap without checking if it's active first. + if (cap->IsRegistered()) + return; + + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Registering cap %s", cap->GetName().c_str()); + cap->bit = AllocateBit(); + cap->extitem = &capext; + caps.insert(std::make_pair(cap->GetName(), cap)); + } + + void DelCap(Cap::Capability* cap) CXX11_OVERRIDE + { + // No-op if the cap is not registered, see AddCap() above + if (!cap->IsRegistered()) + return; + + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Unregistering cap %s", cap->GetName().c_str()); + + // Turn off the cap for all users + const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers(); + for (UserManager::LocalList::const_iterator i = list.begin(); i != list.end(); ++i) + { + LocalUser* user = *i; + cap->set(user, false); + } + + cap->Unregister(); + caps.erase(cap->GetName()); + } + + Capability* Find(const std::string& capname) const CXX11_OVERRIDE + { + CapMap::const_iterator it = caps.find(capname); + if (it != caps.end()) + return it->second; + return NULL; + } + + bool HandleReq(LocalUser* user, const std::string& reqlist) + { + Ext usercaps = capext.get(user); + irc::spacesepstream ss(reqlist); + for (std::string capname; ss.GetToken(capname); ) + { + bool remove = (capname[0] == '-'); + if (remove) + capname.erase(capname.begin()); + + Capability* cap = ManagerImpl::Find(capname); + if (!cap) + return false; + + if (remove) + usercaps = cap->DelFromMask(usercaps); + else + usercaps = cap->AddToMask(usercaps); + } + + capext.set(user, usercaps); + return true; + } + + void HandleList(std::string& out, LocalUser* user, bool show_all, bool minus_prefix = false) const + { + Ext show_caps = (show_all ? ~0 : capext.get(user)); + + for (CapMap::const_iterator i = caps.begin(); i != caps.end(); ++i) + { + Capability* cap = i->second; + if (!(show_caps & cap->GetMask())) + continue; + + if (minus_prefix) + out.push_back('-'); + out.append(cap->GetName()).push_back(' '); + } + } + + void HandleClear(LocalUser* user, std::string& result) + { + HandleList(result, user, false, true); + capext.unset(user); + } +}; + +class CommandCap : public SplitCommand +{ + Cap::ManagerImpl manager; + + static void DisplayResult(LocalUser* user, std::string& result) + { + if (result.size() > 5) + result.erase(result.end()-1); + user->WriteCommand("CAP", result); + } + + public: + LocalIntExt holdext; + + CommandCap(Module* mod) + : SplitCommand(mod, "CAP", 1) + , manager(mod) + , holdext("cap_hold", ExtensionItem::EXT_USER, mod) + { + works_before_reg = true; + } + + CmdResult HandleLocal(const std::vector& parameters, LocalUser* user) CXX11_OVERRIDE + { + if (user->registered != REG_ALL) + holdext.set(user, 1); + + std::string subcommand(parameters[0].length(), ' '); + std::transform(parameters[0].begin(), parameters[0].end(), subcommand.begin(), ::toupper); + + if (subcommand == "REQ") + { + if (parameters.size() < 2) + return CMD_FAILURE; + + std::string result = (manager.HandleReq(user, parameters[1]) ? "ACK :" : "NAK :"); + result.append(parameters[1]); + user->WriteCommand("CAP", result); + } + else if (subcommand == "END") + { + holdext.unset(user); + } + else if ((subcommand == "LS") || (subcommand == "LIST")) + { + const bool is_ls = (subcommand.length() == 2); + + std::string result = subcommand + " :"; + manager.HandleList(result, user, is_ls); + DisplayResult(user, result); + } + else if (subcommand == "CLEAR") + { + std::string result = "ACK :"; + manager.HandleClear(user, result); + DisplayResult(user, result); + } + else + { + user->WriteNumeric(ERR_INVALIDCAPSUBCOMMAND, "%s :Invalid CAP subcommand", subcommand.c_str()); + return CMD_FAILURE; + } + + return CMD_SUCCESS; + } +}; + +class ModuleCap : public Module +{ + CommandCap cmd; + + public: + ModuleCap() + : cmd(this) + { + } + + ModResult OnCheckReady(LocalUser* user) CXX11_OVERRIDE + { + return (cmd.holdext.get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU); + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Provides support for CAP capability negotiation", VF_VENDOR); + } +}; + +MODULE_INIT(ModuleCap) -- cgit v1.2.3 From bc388aa97c1e8ab4ebea729d116e868cff11e137 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:35:05 +0100 Subject: m_cap Add Capability::OnRequest() hook --- include/modules/cap.h | 12 ++++++++++++ src/modules/m_cap.cpp | 10 +++++++++- 2 files changed, 21 insertions(+), 1 deletion(-) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index 9dd44a4aa..4ca3911a5 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -65,6 +65,8 @@ namespace Cap * * The cap module must be loaded for the capability to work. The IsRegistered() method can be used to query whether the cap is actually online or not. * The capability can be deactivated and reactivated with the SetActive() method. Deactivated caps behave as if they don't exist. + * + * It is possible to implement special behavior by inheriting from this class and overriding some of its methods. */ class Capability : public ServiceProvider, private dynamic_reference_base::CaptureHook { @@ -187,5 +189,15 @@ namespace Cap * @return True if the cap is registered in the manager, false otherwise */ bool IsRegistered() const { return (extitem != NULL); } + + /** Called when a user requests to turn this capability on or off. + * @param user User requesting to change the state of the cap + * @param add True if requesting to turn the cap on, false if requesting to turn it off + * @return True to allow the request, false to reject it + */ + virtual bool OnRequest(LocalUser* user, bool add) + { + return true; + } }; } diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index 9e857ad28..bb5a506c9 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -32,6 +32,14 @@ class Cap::ManagerImpl : public Cap::Manager ExtItem capext; CapMap caps; + static bool CanRequest(LocalUser* user, Ext usercaps, Capability* cap, bool adding) + { + if ((usercaps & cap->GetMask()) == adding) + return true; + + return cap->OnRequest(user, adding); + } + Capability::Bit AllocateBit() const { Capability::Bit used = 0; @@ -118,7 +126,7 @@ class Cap::ManagerImpl : public Cap::Manager capname.erase(capname.begin()); Capability* cap = ManagerImpl::Find(capname); - if (!cap) + if ((!cap) || (!CanRequest(user, usercaps, cap, !remove))) return false; if (remove) -- cgit v1.2.3 From 3e08629e8342cfbd17388aa14facf3a3a963233f Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:42:04 +0100 Subject: m_cap Add Capability::OnList() hook --- include/modules/cap.h | 10 ++++++++++ src/modules/m_cap.cpp | 3 +++ 2 files changed, 13 insertions(+) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index 4ca3911a5..a00089260 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -199,5 +199,15 @@ namespace Cap { return true; } + + /** Called when a user requests a list of all capabilities and this capability is about to be included in the list. + * The default behavior always includes the cap in the list. + * @param user User querying a list capabilities + * @return True to add this cap to the list sent to the user, false to not list it + */ + virtual bool OnList(LocalUser* user) + { + return true; + } }; } diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index bb5a506c9..2b4055e3c 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -149,6 +149,9 @@ class Cap::ManagerImpl : public Cap::Manager if (!(show_caps & cap->GetMask())) continue; + if ((show_all) && (!cap->OnList(user))) + continue; + if (minus_prefix) out.push_back('-'); out.append(cap->GetName()).push_back(' '); -- cgit v1.2.3 From 9ac2eae1f0d663cb3b2fc05d6d37b07dcfd9025e Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:45:20 +0100 Subject: m_cap Learn the supported capability negotiation protocol of a client from CAP LS Let modules implementing caps query this information --- include/modules/cap.h | 25 ++++++++++++++++++++++++- src/modules/m_cap.cpp | 12 ++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index a00089260..1ad2ff2f1 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -23,11 +23,24 @@ namespace Cap { - static const unsigned int MAX_CAPS = sizeof(intptr_t) * 8; + static const unsigned int MAX_CAPS = (sizeof(intptr_t) * 8) - 1; + static const intptr_t CAP_302_BIT = (intptr_t)1 << MAX_CAPS; + typedef intptr_t Ext; typedef LocalIntExt ExtItem; class Capability; + enum Protocol + { + /** Supports capability negotiation protocol v3.1, or none + */ + CAP_LEGACY, + + /** Supports capability negotiation v3.2 + */ + CAP_302 + }; + class Manager : public DataProvider { public: @@ -190,6 +203,16 @@ namespace Cap */ bool IsRegistered() const { return (extitem != NULL); } + /** Get the CAP negotiation protocol version of a user. + * The cap must be registered for this to return anything other than CAP_LEGACY. + * @param user User whose negotiation protocol version to query + * @return One of the Capability::Protocol enum indicating the highest supported capability negotiation protocol version + */ + Protocol GetProtocol(LocalUser* user) const + { + return ((IsRegistered() && (extitem->get(user) & CAP_302_BIT)) ? CAP_302 : CAP_LEGACY); + } + /** Called when a user requests to turn this capability on or off. * @param user User requesting to change the state of the cap * @param add True if requesting to turn the cap on, false if requesting to turn it off diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index 2b4055e3c..4411306ed 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -115,6 +115,16 @@ class Cap::ManagerImpl : public Cap::Manager return NULL; } + Protocol GetProtocol(LocalUser* user) const + { + return ((capext.get(user) & CAP_302_BIT) ? CAP_302 : CAP_LEGACY); + } + + void Set302Protocol(LocalUser* user) + { + capext.set(user, capext.get(user) | CAP_302_BIT); + } + bool HandleReq(LocalUser* user, const std::string& reqlist) { Ext usercaps = capext.get(user); @@ -211,6 +221,8 @@ class CommandCap : public SplitCommand else if ((subcommand == "LS") || (subcommand == "LIST")) { const bool is_ls = (subcommand.length() == 2); + if ((is_ls) && (parameters.size() > 1) && (parameters[1] == "302")) + manager.Set302Protocol(user); std::string result = subcommand + " :"; manager.HandleList(result, user, is_ls); -- cgit v1.2.3 From a58f0c00f1153f90701db07b033cf0576e9999e9 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:45:59 +0100 Subject: m_cap Reject CAP CLEAR from clients newer than 3.1 --- src/modules/m_cap.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/modules/m_cap.cpp') diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index 4411306ed..8ba28001e 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -228,7 +228,7 @@ class CommandCap : public SplitCommand manager.HandleList(result, user, is_ls); DisplayResult(user, result); } - else if (subcommand == "CLEAR") + else if ((subcommand == "CLEAR") && (manager.GetProtocol(user) == Cap::CAP_LEGACY)) { std::string result = "ACK :"; manager.HandleClear(user, result); -- cgit v1.2.3 From b9c6792cd6123d9c6c0c30df75b0afe09258376f Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:50:07 +0100 Subject: m_cap Add Capability::GetCapValue(), list capabilities with values --- include/modules/cap.h | 10 ++++++++++ src/modules/m_cap.cpp | 20 ++++++++++++++++---- 2 files changed, 26 insertions(+), 4 deletions(-) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index 1ad2ff2f1..e242720b5 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -25,6 +25,7 @@ namespace Cap { static const unsigned int MAX_CAPS = (sizeof(intptr_t) * 8) - 1; static const intptr_t CAP_302_BIT = (intptr_t)1 << MAX_CAPS; + static const unsigned int MAX_VALUE_LENGTH = 100; typedef intptr_t Ext; typedef LocalIntExt ExtItem; @@ -232,5 +233,14 @@ namespace Cap { return true; } + + /** Query the value of this capability for a user + * @param user User who will get the value of the capability + * @return Value to show to the user. If NULL, the capability has no value (default). + */ + virtual const std::string* GetValue(LocalUser* user) const + { + return NULL; + } }; } diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index 8ba28001e..12de0de08 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -149,7 +149,7 @@ class Cap::ManagerImpl : public Cap::Manager return true; } - void HandleList(std::string& out, LocalUser* user, bool show_all, bool minus_prefix = false) const + void HandleList(std::string& out, LocalUser* user, bool show_all, bool show_values, bool minus_prefix = false) const { Ext show_caps = (show_all ? ~0 : capext.get(user)); @@ -164,13 +164,24 @@ class Cap::ManagerImpl : public Cap::Manager if (minus_prefix) out.push_back('-'); - out.append(cap->GetName()).push_back(' '); + out.append(cap->GetName()); + + if (show_values) + { + const std::string* capvalue = cap->GetValue(user); + if ((capvalue) && (!capvalue->empty()) && (capvalue->find(' ') == std::string::npos)) + { + out.push_back('='); + out.append(*capvalue, 0, MAX_VALUE_LENGTH); + } + } + out.push_back(' '); } } void HandleClear(LocalUser* user, std::string& result) { - HandleList(result, user, false, true); + HandleList(result, user, false, false, true); capext.unset(user); } }; @@ -225,7 +236,8 @@ class CommandCap : public SplitCommand manager.Set302Protocol(user); std::string result = subcommand + " :"; - manager.HandleList(result, user, is_ls); + // Show values only if supports v3.2 and doing LS + manager.HandleList(result, user, is_ls, ((is_ls) && (manager.GetProtocol(user) != Cap::CAP_LEGACY))); DisplayResult(user, result); } else if ((subcommand == "CLEAR") && (manager.GetProtocol(user) == Cap::CAP_LEGACY)) -- cgit v1.2.3 From 912fd7a922beaeecdf602fa9d70964aee2a6bb63 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:57:00 +0100 Subject: m_cap Provide the OnCapAddDel() event --- include/modules/cap.h | 15 +++++++++++++++ src/modules/m_cap.cpp | 13 +++++++++++-- 2 files changed, 26 insertions(+), 2 deletions(-) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index e242720b5..e05263ad3 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -42,6 +42,21 @@ namespace Cap CAP_302 }; + class EventListener : public Events::ModuleEventListener + { + public: + EventListener(Module* mod) + : ModuleEventListener(mod, "event/cap") + { + } + + /** Called whenever a new client capability becomes available or unavailable + * @param cap Capability being added or removed + * @param add If true, the capability is being added, otherwise its being removed + */ + virtual void OnCapAddDel(Capability* cap, bool add) = 0; + }; + class Manager : public DataProvider { public: diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index 12de0de08..a6b5aa900 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -31,6 +31,7 @@ class Cap::ManagerImpl : public Cap::Manager ExtItem capext; CapMap caps; + Events::ModuleEventProvider& evprov; static bool CanRequest(LocalUser* user, Ext usercaps, Capability* cap, bool adding) { @@ -59,9 +60,10 @@ class Cap::ManagerImpl : public Cap::Manager } public: - ManagerImpl(Module* mod) + ManagerImpl(Module* mod, Events::ModuleEventProvider& evprovref) : Cap::Manager(mod) , capext("caps", ExtensionItem::EXT_USER, mod) + , evprov(evprovref) { } @@ -85,6 +87,8 @@ class Cap::ManagerImpl : public Cap::Manager cap->bit = AllocateBit(); cap->extitem = &capext; caps.insert(std::make_pair(cap->GetName(), cap)); + + FOREACH_MOD_CUSTOM(evprov, Cap::EventListener, OnCapAddDel, (cap, true)); } void DelCap(Cap::Capability* cap) CXX11_OVERRIDE @@ -95,6 +99,9 @@ class Cap::ManagerImpl : public Cap::Manager ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Unregistering cap %s", cap->GetName().c_str()); + // Fire the event first so modules can still see who is using the cap which is being unregistered + FOREACH_MOD_CUSTOM(evprov, Cap::EventListener, OnCapAddDel, (cap, false)); + // Turn off the cap for all users const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers(); for (UserManager::LocalList::const_iterator i = list.begin(); i != list.end(); ++i) @@ -188,6 +195,7 @@ class Cap::ManagerImpl : public Cap::Manager class CommandCap : public SplitCommand { + Events::ModuleEventProvider evprov; Cap::ManagerImpl manager; static void DisplayResult(LocalUser* user, std::string& result) @@ -202,7 +210,8 @@ class CommandCap : public SplitCommand CommandCap(Module* mod) : SplitCommand(mod, "CAP", 1) - , manager(mod) + , evprov(mod, "event/cap") + , manager(mod, evprov) , holdext("cap_hold", ExtensionItem::EXT_USER, mod) { works_before_reg = true; -- cgit v1.2.3 From 302053cf8f5378da7f23e5d2f68a24c9d2325351 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 15:58:48 +0100 Subject: m_cap Provide the OnCapValueChange event and add Cap::Manager::NotifyValueChange() --- include/modules/cap.h | 20 ++++++++++++++++++++ src/modules/m_cap.cpp | 6 ++++++ 2 files changed, 26 insertions(+) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index e05263ad3..6f91f5aee 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -55,6 +55,11 @@ namespace Cap * @param add If true, the capability is being added, otherwise its being removed */ virtual void OnCapAddDel(Capability* cap, bool add) = 0; + + /** Called whenever the value of a cap changes. + * @param cap Capability whose value changed + */ + virtual void OnCapValueChange(Capability* cap) { } }; class Manager : public DataProvider @@ -82,6 +87,11 @@ namespace Cap * @return Capability object pointer if found, NULL otherwise */ virtual Capability* Find(const std::string& name) const = 0; + + /** Notify manager when a value of a cap changed + * @param cap Cap whose value changed + */ + virtual void NotifyValueChange(Capability* cap) = 0; }; /** Represents a client capability. @@ -135,6 +145,16 @@ namespace Cap friend class ManagerImpl; + protected: + /** Notify the manager that the value of the capability changed. + * Must be called if the value of the cap changes for any reason. + */ + void NotifyValueChange() + { + if (IsRegistered()) + manager->NotifyValueChange(this); + } + public: /** Constructor, initializes the capability. * Caps are active by default. diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index a6b5aa900..e1593e33f 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -122,6 +122,12 @@ class Cap::ManagerImpl : public Cap::Manager return NULL; } + void NotifyValueChange(Capability* cap) CXX11_OVERRIDE + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Cap %s changed value", cap->GetName().c_str()); + FOREACH_MOD_CUSTOM(evprov, Cap::EventListener, OnCapValueChange, (cap)); + } + Protocol GetProtocol(LocalUser* user) const { return ((capext.get(user) & CAP_302_BIT) ? CAP_302 : CAP_LEGACY); -- cgit v1.2.3 From 425d54073a0ae61c68de1b339177bb7c0db116f1 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 16:16:49 +0100 Subject: m_cap Specialize extension item --- include/modules/cap.h | 9 ++++++++- src/modules/m_cap.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 2 deletions(-) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index 6f91f5aee..9ff5faca9 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -28,7 +28,14 @@ namespace Cap static const unsigned int MAX_VALUE_LENGTH = 100; typedef intptr_t Ext; - typedef LocalIntExt ExtItem; + class ExtItem : public LocalIntExt + { + public: + ExtItem(Module* mod); + std::string serialize(SerializeFormat format, const Extensible* container, void* item) const; + void unserialize(SerializeFormat format, Extensible* container, const std::string& value); + }; + class Capability; enum Protocol diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index e1593e33f..bfce2e68c 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -25,6 +25,8 @@ namespace Cap class ManagerImpl; } +static Cap::ManagerImpl* managerimpl; + class Cap::ManagerImpl : public Cap::Manager { typedef insp::flat_map CapMap; @@ -62,9 +64,10 @@ class Cap::ManagerImpl : public Cap::Manager public: ManagerImpl(Module* mod, Events::ModuleEventProvider& evprovref) : Cap::Manager(mod) - , capext("caps", ExtensionItem::EXT_USER, mod) + , capext(mod) , evprov(evprovref) { + managerimpl = this; } ~ManagerImpl() @@ -199,6 +202,56 @@ class Cap::ManagerImpl : public Cap::Manager } }; +Cap::ExtItem::ExtItem(Module* mod) + : LocalIntExt("caps", ExtensionItem::EXT_USER, mod) +{ +} + +std::string Cap::ExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const +{ + std::string ret; + // XXX: Cast away the const because IS_LOCAL() doesn't handle it + LocalUser* user = IS_LOCAL(const_cast(static_cast(container))); + if ((format == FORMAT_NETWORK) || (!user)) + return ret; + + // List requested caps + managerimpl->HandleList(ret, user, false, false); + + // Serialize cap protocol version. If building a human-readable string append a new token, otherwise append only a single character indicating the version. + Protocol protocol = managerimpl->GetProtocol(user); + if (format == FORMAT_USER) + ret.append("capversion=3."); + else if (!ret.empty()) + ret.erase(ret.length()-1); + + if (protocol == CAP_302) + ret.push_back('2'); + else + ret.push_back('1'); + + return ret; +} + +void Cap::ExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value) +{ + if (format == FORMAT_NETWORK) + return; + + LocalUser* user = IS_LOCAL(static_cast(container)); + if (!user) + return; // Can't happen + + // Process the cap protocol version which is a single character at the end of the serialized string + const char verchar = *value.rbegin(); + if (verchar == '2') + managerimpl->Set302Protocol(user); + + // Remove the version indicator from the string passed to HandleReq + std::string caplist(value, 0, value.size()-1); + managerimpl->HandleReq(user, caplist); +} + class CommandCap : public SplitCommand { Events::ModuleEventProvider evprov; -- cgit v1.2.3 From 4a02829e4ff8b89f48104d5a98eaad9d3739f594 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 16:24:12 +0100 Subject: m_cap Save and restore the cap state of a module when it is reloaded --- src/modules/m_cap.cpp | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) (limited to 'src/modules/m_cap.cpp') diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index bfce2e68c..c01377f46 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -18,6 +18,7 @@ #include "inspircd.h" +#include "modules/reload.h" #include "modules/cap.h" namespace Cap @@ -27,8 +28,25 @@ namespace Cap static Cap::ManagerImpl* managerimpl; -class Cap::ManagerImpl : public Cap::Manager +class Cap::ManagerImpl : public Cap::Manager, public ReloadModule::EventListener { + /** Stores the cap state of a module being reloaded + */ + struct CapModData + { + struct Data + { + std::string name; + std::vector users; + + Data(Capability* cap) + : name(cap->GetName()) + { + } + }; + std::vector caps; + }; + typedef insp::flat_map CapMap; ExtItem capext; @@ -61,9 +79,71 @@ class Cap::ManagerImpl : public Cap::Manager throw ModuleException("Too many caps"); } + void OnReloadModuleSave(Module* mod, ReloadModule::CustomData& cd) CXX11_OVERRIDE + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "OnReloadModuleSave()"); + if (mod == creator) + return; + + CapModData* capmoddata = new CapModData; + cd.add(this, capmoddata); + + for (CapMap::iterator i = caps.begin(); i != caps.end(); ++i) + { + Capability* cap = i->second; + // Only save users of caps that belong to the module being reloaded + if (cap->creator != mod) + continue; + + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Module being reloaded implements cap %s, saving cap users", cap->GetName().c_str()); + capmoddata->caps.push_back(CapModData::Data(cap)); + CapModData::Data& capdata = capmoddata->caps.back(); + + // Populate list with uuids of users who are using the cap + const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers(); + for (UserManager::LocalList::const_iterator j = list.begin(); j != list.end(); ++j) + { + LocalUser* user = *j; + if (cap->get(user)) + capdata.users.push_back(user->uuid); + } + } + } + + void OnReloadModuleRestore(Module* mod, void* data) CXX11_OVERRIDE + { + CapModData* capmoddata = static_cast(data); + for (std::vector::const_iterator i = capmoddata->caps.begin(); i != capmoddata->caps.end(); ++i) + { + const CapModData::Data& capdata = *i; + Capability* cap = ManagerImpl::Find(capdata.name); + if (!cap) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Cap %s is no longer available after reload", capdata.name.c_str()); + continue; + } + + // Set back the cap for all users who were using it before the reload + for (std::vector::const_iterator j = capdata.users.begin(); j != capdata.users.end(); ++j) + { + const std::string& uuid = *j; + User* user = ServerInstance->FindUUID(uuid); + if (!user) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "User %s is gone when trying to restore cap %s", uuid.c_str(), capdata.name.c_str()); + continue; + } + + cap->set(user, true); + } + } + delete capmoddata; + } + public: ManagerImpl(Module* mod, Events::ModuleEventProvider& evprovref) : Cap::Manager(mod) + , ReloadModule::EventListener(mod) , capext(mod) , evprov(evprovref) { -- cgit v1.2.3 From c933f324085d025d4b1b96f4405cdffff52e9256 Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 16:42:17 +0100 Subject: m_cap Make Capability objects compatible with dynamic_references, add Cap::Reference --- include/modules/cap.h | 28 ++++++++++++++++++++++++++++ src/modules/m_cap.cpp | 2 ++ 2 files changed, 30 insertions(+) (limited to 'src/modules/m_cap.cpp') diff --git a/include/modules/cap.h b/include/modules/cap.h index 9ff5faca9..e6f9340e8 100644 --- a/include/modules/cap.h +++ b/include/modules/cap.h @@ -285,4 +285,32 @@ namespace Cap return NULL; } }; + + /** Reference to a cap. The cap may be provided by another module. + */ + class Reference + { + dynamic_reference_nocheck ref; + + public: + /** Constructor, initializes the capability reference + * @param mod Module creating this object + * @param Name Raw name of the cap as used in the protocol (CAP LS, etc.) + */ + Reference(Module* mod, const std::string& Name) + : ref(mod, "cap/" + Name) + { + } + + /** Check whether a user has the referenced capability turned on. + * @param user User to check + * @return True if the user is using the referenced capability, false otherwise + */ + bool get(LocalUser* user) + { + if (ref) + return ref->get(user); + return false; + } + }; } diff --git a/src/modules/m_cap.cpp b/src/modules/m_cap.cpp index c01377f46..3e9c37a34 100644 --- a/src/modules/m_cap.cpp +++ b/src/modules/m_cap.cpp @@ -170,6 +170,7 @@ class Cap::ManagerImpl : public Cap::Manager, public ReloadModule::EventListener cap->bit = AllocateBit(); cap->extitem = &capext; caps.insert(std::make_pair(cap->GetName(), cap)); + ServerInstance->Modules.AddReferent("cap/" + cap->GetName(), cap); FOREACH_MOD_CUSTOM(evprov, Cap::EventListener, OnCapAddDel, (cap, true)); } @@ -193,6 +194,7 @@ class Cap::ManagerImpl : public Cap::Manager, public ReloadModule::EventListener cap->set(user, false); } + ServerInstance->Modules.DelReferent(cap); cap->Unregister(); caps.erase(cap->GetName()); } -- cgit v1.2.3