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 ModuleIRCv3CapNotify : public Module, public Cap::EventListener, public ReloadModule::EventListener
  50 {
  51         CapNotify capnotify;
  52         std::string reloadedmod;
  53         std::vector<std::string> reloadedcaps;
  54
  55         void Send(const std::string& capname, Cap::Capability* cap, bool add)
  56         {
  57                 std::string msg = (add ? "NEW :" : "DEL :");
  58                 msg.append(capname);
  59                 std::string msgwithval = msg;
  60                 msgwithval.push_back('=');
  61                 std::string::size_type msgpos = msgwithval.size();
  62
  63                 const UserManager::LocalList& list = ServerInstance->Users.GetLocalUsers();
  64                 for (UserManager::LocalList::const_iterator i = list.begin(); i != list.end(); ++i)
  65                 {
  66                         LocalUser* user = *i;
  67                         if (!capnotify.get(user))
  68                                 continue;
  69
  70                         // If the cap is being added and the client supports cap values then show the value, if any
  71                         if ((add) && (capnotify.GetProtocol(user) != Cap::CAP_LEGACY))
  72                         {
  73                                 const std::string* capvalue = cap->GetValue(user);
  74                                 if ((capvalue) && (!capvalue->empty()))
  75                                 {
  76                                         msgwithval.append(*capvalue);
  77                                         user->WriteCommand("CAP", msgwithval);
  78                                         msgwithval.erase(msgpos);
  79                                         continue;
  80                                 }
  81                         }
  82                         user->WriteCommand("CAP", msg);
  83                 }
  84         }
  85
  86  public:
  87         ModuleIRCv3CapNotify()
  88                 : Cap::EventListener(this)
  89                 , ReloadModule::EventListener(this)
  90                 , capnotify(this)
  91         {
  92         }
  93
  94         void OnCapAddDel(Cap::Capability* cap, bool add) CXX11_OVERRIDE
  95         {
  96                 if (cap->creator == this)
  97                         return;
  98
  99                 if (cap->creator->ModuleSourceFile == reloadedmod)
 100                 {
 101                         if (!add)
 102                                 reloadedcaps.push_back(cap->GetName());
 103                         return;
 104                 }
 105                 Send(cap->GetName(), cap, add);
 106         }
 107
 108         void OnCapValueChange(Cap::Capability* cap) CXX11_OVERRIDE
 109         {
 110                 // The value of a cap has changed, send CAP DEL and CAP NEW with the new value
 111                 Send(cap->GetName(), cap, false);
 112                 Send(cap->GetName(), cap, true);
 113         }
 114
 115         void OnReloadModuleSave(Module* mod, ReloadModule::CustomData& cd) CXX11_OVERRIDE
 116         {
 117                 if (mod == this)
 118                         return;
 119                 reloadedmod = mod->ModuleSourceFile;
 120                 // Request callback when reload is complete
 121                 cd.add(this, NULL);
 122         }
 123
 124         void OnReloadModuleRestore(Module* mod, void* data) CXX11_OVERRIDE
 125         {
 126                 // Reloading can change the set of caps provided by a module so assuming that if the reload succeded all
 127                 // caps that the module previously provided are available or all were lost if the reload failed is wrong.
 128                 // Instead, we verify the availability of each cap individually.
 129                 dynamic_reference_nocheck<Cap::Manager> capmanager(this, "capmanager");
 130                 if (capmanager)
 131                 {
 132                         for (std::vector<std::string>::const_iterator i = reloadedcaps.begin(); i != reloadedcaps.end(); ++i)
 133                         {
 134                                 const std::string& capname = *i;
 135                                 if (!capmanager->Find(capname))
 136                                         Send(capname, NULL, false);
 137                         }
 138                 }
 139                 reloadedmod.clear();
 140                 reloadedcaps.clear();
 141         }
 142
 143         Version GetVersion() CXX11_OVERRIDE
 144         {
 145                 return Version("Provides the cap-notify IRCv3.2 extension", VF_VENDOR);
 146         }
 147 };
 148
 149 MODULE_INIT(ModuleIRCv3CapNotify)