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 --- include/modules/cap.h | 191 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 include/modules/cap.h (limited to 'include/modules') diff --git a/include/modules/cap.h b/include/modules/cap.h new file mode 100644 index 000000000..9dd44a4aa --- /dev/null +++ b/include/modules/cap.h @@ -0,0 +1,191 @@ +/* + * 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 . + */ + + +#pragma once + +#include "event.h" + +namespace Cap +{ + static const unsigned int MAX_CAPS = sizeof(intptr_t) * 8; + typedef intptr_t Ext; + typedef LocalIntExt ExtItem; + class Capability; + + class Manager : public DataProvider + { + public: + Manager(Module* mod) + : DataProvider(mod, "capmanager") + { + } + + /** Register a client capability. + * Modules should call Capability::SetActive(true) instead of this method. + * @param cap Capability to register + */ + virtual void AddCap(Capability* cap) = 0; + + /** Unregister a client capability. + * Modules should call Capability::SetActive(false) instead of this method. + * @param cap Capability to unregister + */ + virtual void DelCap(Capability* cap) = 0; + + /** Find a capability by name + * @param name Capability to find + * @return Capability object pointer if found, NULL otherwise + */ + virtual Capability* Find(const std::string& name) const = 0; + }; + + /** Represents a client capability. + * + * Capabilities offer extensions to the client to server protocol. They must be negotiated with clients before they have any effect on the protocol. + * Each cap must have a unique name that is used during capability negotiation. + * + * After construction the cap is ready to be used by clients without any further setup, like other InspIRCd services. + * The get() method accepts a user as parameter and can be used to check whether that user has negotiated usage of the cap. This is only known for local users. + * + * 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. + */ + class Capability : public ServiceProvider, private dynamic_reference_base::CaptureHook + { + typedef size_t Bit; + + /** Bit allocated to this cap, undefined if the cap is unregistered + */ + Bit bit; + + /** Extension containing all caps set by a user. NULL if the cap is unregistered. + */ + ExtItem* extitem; + + /** True if the cap is active. Only active caps are registered in the manager. + */ + bool active; + + /** Reference to the cap manager object + */ + dynamic_reference manager; + + void OnCapture() CXX11_OVERRIDE + { + if (active) + SetActive(true); + } + + void Unregister() + { + bit = 0; + extitem = NULL; + } + + Ext AddToMask(Ext mask) const { return (mask | GetMask()); } + Ext DelFromMask(Ext mask) const { return (mask & (~GetMask())); } + Bit GetMask() const { return bit; } + + friend class ManagerImpl; + + public: + /** Constructor, initializes the capability. + * Caps are active by default. + * @param mod Module providing the cap + * @param Name Raw name of the cap as used in the protocol (CAP LS, etc.) + */ + Capability(Module* mod, const std::string& Name) + : ServiceProvider(mod, Name, SERVICE_CUSTOM) + , active(true) + , manager(mod, "capmanager") + { + Unregister(); + } + + ~Capability() + { + SetActive(false); + } + + void RegisterService() CXX11_OVERRIDE + { + manager.SetCaptureHook(this); + SetActive(true); + } + + /** Check whether a user has the capability turned on. + * This method is safe to call if the cap is unregistered and will return false. + * @param user User to check + * @return True if the user is using this capability, false otherwise + */ + bool get(User* user) const + { + if (!IsRegistered()) + return false; + Ext caps = extitem->get(user); + return (caps & GetMask()); + } + + /** Turn the capability on/off for a user. If the cap is not registered this method has no effect. + * @param user User to turn the cap on/off for + * @param val True to turn the cap on, false to turn it off + */ + void set(User* user, bool val) + { + if (!IsRegistered()) + return; + Ext curr = extitem->get(user); + extitem->set(user, (val ? AddToMask(curr) : DelFromMask(curr))); + } + + /** Activate or deactivate the capability. + * If activating, the cap is marked as active and if the manager is available the cap is registered in the manager. + * If deactivating, the cap is marked as inactive and if it is registered, it will be unregistered. + * Users who had the cap turned on will have it turned off automatically. + * @param activate True to activate the cap, false to deactivate it + */ + void SetActive(bool activate) + { + active = activate; + if (manager) + { + if (activate) + manager->AddCap(this); + else + manager->DelCap(this); + } + } + + /** Get the name of the capability that's used in the protocol + * @return Name of the capability as used in the protocol + */ + const std::string& GetName() const { return name; } + + /** Check whether the capability is active. The cap must be active and registered to be used by users. + * @return True if the cap is active, false if it has been deactivated + */ + bool IsActive() const { return active; } + + /** Check whether the capability is registered + * The cap must be active and the manager must be available for a cap to be registered. + * @return True if the cap is registered in the manager, false otherwise + */ + bool IsRegistered() const { return (extitem != NULL); } + }; +} -- 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 'include/modules') 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 'include/modules') 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 'include/modules') 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 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 'include/modules') 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 'include/modules') 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 'include/modules') 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 'include/modules') 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 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 'include/modules') 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 From 18d5754871de9f0de35c06fbbe4fce6c55c1752f Mon Sep 17 00:00:00 2001 From: Attila Molnar Date: Sat, 5 Dec 2015 16:47:41 +0100 Subject: m_ircv3 Make WriteNeighborsWithCap() available for use in other modules --- include/modules/ircv3.h | 45 +++++++++++++++++++++++++++++++++++++++++++++ src/modules/m_ircv3.cpp | 25 +++---------------------- 2 files changed, 48 insertions(+), 22 deletions(-) create mode 100644 include/modules/ircv3.h (limited to 'include/modules') diff --git a/include/modules/ircv3.h b/include/modules/ircv3.h new file mode 100644 index 000000000..e03ee16fa --- /dev/null +++ b/include/modules/ircv3.h @@ -0,0 +1,45 @@ +/* + * 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 . + */ + + +#pragma once + +namespace IRCv3 +{ + class WriteNeighborsWithCap; +} + +class IRCv3::WriteNeighborsWithCap : public User::ForEachNeighborHandler +{ + const Cap::Capability& cap; + const std::string& msg; + + void Execute(LocalUser* user) CXX11_OVERRIDE + { + if (cap.get(user)) + user->Write(msg); + } + + public: + WriteNeighborsWithCap(User* user, const std::string& message, const Cap::Capability& capability) + : cap(capability) + , msg(message) + { + user->ForEachNeighbor(*this, false); + } +}; diff --git a/src/modules/m_ircv3.cpp b/src/modules/m_ircv3.cpp index c99d920ba..5275e9bd5 100644 --- a/src/modules/m_ircv3.cpp +++ b/src/modules/m_ircv3.cpp @@ -19,26 +19,7 @@ #include "inspircd.h" #include "modules/account.h" #include "modules/cap.h" - -class WriteNeighborsWithCap : public User::ForEachNeighborHandler -{ - const Cap::Capability& cap; - const std::string& msg; - - void Execute(LocalUser* user) CXX11_OVERRIDE - { - if (cap.get(user)) - user->Write(msg); - } - - public: - WriteNeighborsWithCap(User* user, const std::string& message, const Cap::Capability& capability) - : cap(capability) - , msg(message) - { - user->ForEachNeighbor(*this, false); - } -}; +#include "modules/ircv3.h" class ModuleIRCv3 : public Module, public AccountEventListener { @@ -76,7 +57,7 @@ class ModuleIRCv3 : public Module, public AccountEventListener else line += newaccount; - WriteNeighborsWithCap(user, line, cap_accountnotify); + IRCv3::WriteNeighborsWithCap(user, line, cap_accountnotify); } void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts) CXX11_OVERRIDE @@ -162,7 +143,7 @@ class ModuleIRCv3 : public Module, public AccountEventListener if (!awaymsg.empty()) line += " :" + awaymsg; - WriteNeighborsWithCap(user, line, cap_awaynotify); + IRCv3::WriteNeighborsWithCap(user, line, cap_awaynotify); } return MOD_RES_PASSTHRU; } -- cgit v1.2.3