src/modules/m_ircv3_capnotify.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2015 Attila Molnar <attilamolnar@hush.com>
   5  *
   6  * This file is part of InspIRCd.  InspIRCd is free software: you can
   7  * redistribute it and/or modify it under the terms of the GNU General Public
   8  * License as published by the Free Software Foundation, version 2.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  13  * details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #include "inspircd.h"
  21 #include "modules/cap.h"
  22 #include "modules/reload.h"
  23
  24 class CapNotify : public Cap::Capability
  25 {
  26         bool OnRequest(LocalUser* user, bool add) CXX11_OVERRIDE
  27         {
  28                 // Users using the negotiation protocol v3.2 or newer may not turn off cap-notify
  29                 if ((!add) && (GetProtocol(user) != Cap::CAP_LEGACY))
  30                         return false;
  31                 return true;
  32         }
  33
  34         bool OnList(LocalUser* user) CXX11_OVERRIDE
  35         {
  36                 // If the client supports 3.2 enable cap-notify for them
  37                 if (GetProtocol(user) != Cap::CAP_LEGACY)
  38                         set(user, true);
  39                 return true;
  40         }
  41
  42  public:
  43         CapNotify(Module* mod)
  44                 : Cap::Capability(mod, "cap-notify")
  45         {
  46         }
  47 };
  48
  49 class CapNotifyMessage : public Cap::MessageBase
  50 {
  51  public:
  52         CapNotifyMessage(bool add, const std::string& capname)
  53                 : Cap::MessageBase((add ? "NEW" : "DEL"))
  54         {
  55                 PushParamRef(capname);
  56         }
  57 };
  58
  59 class CapNotifyValueMessage : public Cap::MessageBase
  60 {
  61         std::string s;
  62         const std::string::size_type pos;
  63
  64  public:
  65         CapNotifyValueMessage(const std::string& capname)
  66                 : Cap::MessageBase("NEW")
  67                 , s(capname)
  68                 , pos(s.size()+1)
  69         {
  70                 s.push_back('=');
  71                 PushParamRef(s);
  72         }
  73
  74         void SetCapValue(const std::string& capvalue)
  75         {
  76                 s.erase(pos);
  77                 s.append(capvalue);
  78                 InvalidateCache();
  79         }
  80 };
  81
  82 class ModuleIRCv3CapNotify : public Module, public Cap::EventListener, public ReloadModule::EventListener
  83 {
  84         CapNotify capnotify;
  85         std::string reloadedmod;
  86         std::vector<std::string> reloadedcaps;
  87         ClientProtocol::EventProvider protoev;
  88
  89         void Send(const std::string& capname, Cap::Capability* cap, bool add)
  90         {
  91                 CapNotifyMessage msg(add, capname);
  92                 CapNotifyValueMessage msgwithval(capname);
  93
  94                 ClientProtocol::Event event(protoev, msg);
  95                 ClientProtocol::Event eventwithval(protoev, msgwithval);
  96
  97                 const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers();
  98                 for (UserManager::LocalList::const_iterator i = list.begin(); i != list.end(); ++i)
  99                 {
 100                         LocalUser* user = *i;
 101                         if (!capnotify.get(user))
 102                                 continue;
 103
 104                         // If the cap is being added and the client supports cap values then show the value, if any
 105                         if ((add) && (capnotify.GetProtocol(user) != Cap::CAP_LEGACY))
 106                         {
 107                                 const std::string* capvalue = cap->GetValue(user);
 108                                 if ((capvalue) && (!capvalue->empty()))
 109                                 {
 110                                         msgwithval.SetUser(user);
 111                                         msgwithval.SetCapValue(*capvalue);
 112                                         user->Send(eventwithval);
 113                                         continue;
 114                                 }
 115                         }
 116                         msg.SetUser(user);
 117                         user->Send(event);
 118                 }
 119         }
 120
 121  public:
 122         ModuleIRCv3CapNotify()
 123                 : Cap::EventListener(this)
 124                 , ReloadModule::EventListener(this)
 125                 , capnotify(this)
 126                 , protoev(this, "CAP_NOTIFY")
 127         {
 128         }
 129
 130         void OnCapAddDel(Cap::Capability* cap, bool add) CXX11_OVERRIDE
 131         {
 132                 if (cap->creator == this)
 133                         return;
 134
 135                 if (cap->creator->ModuleSourceFile == reloadedmod)
 136                 {
 137                         if (!add)
 138                                 reloadedcaps.push_back(cap->GetName());
 139                         return;
 140                 }
 141                 Send(cap->GetName(), cap, add);
 142         }
 143
 144         void OnCapValueChange(Cap::Capability* cap) CXX11_OVERRIDE
 145         {
 146                 // The value of a cap has changed, send CAP DEL and CAP NEW with the new value
 147                 Send(cap->GetName(), cap, false);
 148                 Send(cap->GetName(), cap, true);
 149         }
 150
 151         void OnReloadModuleSave(Module* mod, ReloadModule::CustomData& cd) CXX11_OVERRIDE
 152         {
 153                 if (mod == this)
 154                         return;
 155                 reloadedmod = mod->ModuleSourceFile;
 156                 // Request callback when reload is complete
 157                 cd.add(this, NULL);
 158         }
 159
 160         void OnReloadModuleRestore(Module* mod, void* data) CXX11_OVERRIDE
 161         {
 162                 // Reloading can change the set of caps provided by a module so assuming that if the reload succeded all
 163                 // caps that the module previously provided are available or all were lost if the reload failed is wrong.
 164                 // Instead, we verify the availability of each cap individually.
 165                 dynamic_reference_nocheck<Cap::Manager> capmanager(this, "capmanager");
 166                 if (capmanager)
 167                 {
 168                         for (std::vector<std::string>::const_iterator i = reloadedcaps.begin(); i != reloadedcaps.end(); ++i)
 169                         {
 170                                 const std::string& capname = *i;
 171                                 if (!capmanager->Find(capname))
 172                                         Send(capname, NULL, false);
 173                         }
 174                 }
 175                 reloadedmod.clear();
 176                 reloadedcaps.clear();
 177         }
 178
 179         Version GetVersion() CXX11_OVERRIDE
 180         {
 181                 return Version("Provides the cap-notify IRCv3.2 extension", VF_VENDOR);
 182         }
 183 };
 184
 185 MODULE_INIT(ModuleIRCv3CapNotify)