src/modules/m_ircv3.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2012 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 /* $ModDesc: Provides support for extended-join, away-notify and account-notify CAP capabilities */
  20
  21 #include "inspircd.h"
  22 #include "account.h"
  23 #include "m_cap.h"
  24
  25 class ModuleIRCv3 : public Module
  26 {
  27         GenericCap cap_accountnotify;
  28         GenericCap cap_awaynotify;
  29         GenericCap cap_extendedjoin;
  30         bool accountnotify;
  31         bool awaynotify;
  32         bool extendedjoin;
  33
  34         CUList last_excepts;
  35
  36         void WriteNeighboursWithExt(User* user, const std::string& line, const LocalIntExt& ext)
  37         {
  38                 UserChanList chans(user->chans);
  39
  40                 std::map<User*, bool> exceptions;
  41                 FOREACH_MOD(I_OnBuildNeighborList, OnBuildNeighborList(user, chans, exceptions));
  42
  43                 // Send it to all local users who were explicitly marked as neighbours by modules and have the required ext
  44                 for (std::map<User*, bool>::const_iterator i = exceptions.begin(); i != exceptions.end(); ++i)
  45                 {
  46                         LocalUser* u = IS_LOCAL(i->first);
  47                         if ((u) && (i->second) && (ext.get(u)))
  48                                 u->Write(line);
  49                 }
  50
  51                 // Now consider sending it to all other users who has at least a common channel with the user
  52                 std::set<User*> already_sent;
  53                 for (UCListIter i = chans.begin(); i != chans.end(); ++i)
  54                 {
  55                         const UserMembList* userlist = (*i)->GetUsers();
  56                         for (UserMembList::const_iterator m = userlist->begin(); m != userlist->end(); ++m)
  57                         {
  58                                 /*
  59                                  * Send the line if the channel member in question meets all of the following criteria:
  60                                  * - local
  61                                  * - not the user who is doing the action (i.e. whose channels we're iterating)
  62                                  * - has the given extension
  63                                  * - not on the except list built by modules
  64                                  * - we haven't sent the line to the member yet
  65                                  *
  66                                  */
  67                                 LocalUser* member = IS_LOCAL(m->first);
  68                                 if ((member) && (member != user) && (ext.get(member)) && (exceptions.find(member) == exceptions.end()) && (already_sent.insert(member).second))
  69                                         member->Write(line);
  70                         }
  71                 }
  72         }
  73
  74  public:
  75         ModuleIRCv3() : cap_accountnotify(this, "account-notify"),
  76                                         cap_awaynotify(this, "away-notify"),
  77                                         cap_extendedjoin(this, "extended-join")
  78         {
  79         }
  80
  81         void init()
  82         {
  83                 OnRehash(NULL);
  84                 Implementation eventlist[] = { I_OnUserJoin, I_OnPostJoin, I_OnSetAway, I_OnEvent, I_OnRehash };
  85                 ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
  86         }
  87
  88         void OnRehash(User* user)
  89         {
  90                 ConfigTag* conf = ServerInstance->Config->ConfValue("ircv3");
  91                 accountnotify = conf->getBool("accountnotify", conf->getBool("accoutnotify", true));
  92                 awaynotify = conf->getBool("awaynotify", true);
  93                 extendedjoin = conf->getBool("extendedjoin", true);
  94         }
  95
  96         void OnEvent(Event& ev)
  97         {
  98                 if (awaynotify)
  99                         cap_awaynotify.HandleEvent(ev);
 100                 if (extendedjoin)
 101                         cap_extendedjoin.HandleEvent(ev);
 102
 103                 if (accountnotify)
 104                 {
 105                         cap_accountnotify.HandleEvent(ev);
 106
 107                         if (ev.id == "account_login")
 108                         {
 109                                 AccountEvent* ae = static_cast<AccountEvent*>(&ev);
 110
 111                                 // :nick!user@host ACCOUNT account
 112                                 // or
 113                                 // :nick!user@host ACCOUNT *
 114                                 std::string line =  ":" + ae->user->GetFullHost() + " ACCOUNT ";
 115                                 if (ae->account.empty())
 116                                         line += "*";
 117                                 else
 118                                         line += std::string(ae->account);
 119
 120                                 WriteNeighboursWithExt(ae->user, line, cap_accountnotify.ext);
 121                         }
 122                 }
 123         }
 124
 125         void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts)
 126         {
 127                 // Remember who is not going to see the JOIN because of other modules
 128                 if ((awaynotify) && (IS_AWAY(memb->user)))
 129                         last_excepts = excepts;
 130
 131                 if (!extendedjoin)
 132                         return;
 133
 134                 /*
 135                  * Send extended joins to clients who have the extended-join capability.
 136                  * An extended join looks like this:
 137                  *
 138                  * :nick!user@host JOIN #chan account :realname
 139                  *
 140                  * account is the joining user's account if he's logged in, otherwise it's an asterisk (*).
 141                  */
 142
 143                 std::string line;
 144                 std::string mode;
 145
 146                 const UserMembList* userlist = memb->chan->GetUsers();
 147                 for (UserMembCIter it = userlist->begin(); it != userlist->end(); ++it)
 148                 {
 149                         // Send the extended join line if the current member is local, has the extended-join cap and isn't excepted
 150                         User* member = IS_LOCAL(it->first);
 151                         if ((member) && (cap_extendedjoin.ext.get(member)) && (excepts.find(member) == excepts.end()))
 152                         {
 153                                 // Construct the lines we're going to send if we haven't constructed them already
 154                                 if (line.empty())
 155                                 {
 156                                         bool has_account = false;
 157                                         line = ":" + memb->user->GetFullHost() + " JOIN " + memb->chan->name + " ";
 158                                         const AccountExtItem* accountext = GetAccountExtItem();
 159                                         if (accountext)
 160                                         {
 161                                                 std::string* accountname;
 162                                                 accountname = accountext->get(memb->user);
 163                                                 if (accountname)
 164                                                 {
 165                                                         line += *accountname;
 166                                                         has_account = true;
 167                                                 }
 168                                         }
 169
 170                                         if (!has_account)
 171                                                 line += "*";
 172
 173                                         line += " :" + memb->user->fullname;
 174
 175                                         // If the joining user received privileges from another module then we must send them as well,
 176                                         // since silencing the normal join means the MODE will be silenced as well
 177                                         if (!memb->modes.empty())
 178                                         {
 179                                                 const std::string& modefrom = ServerInstance->Config->CycleHostsFromUser ? memb->user->GetFullHost() : ServerInstance->Config->ServerName;
 180                                                 mode = ":" + modefrom + " MODE " + memb->chan->name + " +" + memb->modes;
 181
 182                                                 for (unsigned int i = 0; i < memb->modes.length(); i++)
 183                                                         mode += " " + memb->user->nick;
 184                                         }
 185                                 }
 186
 187                                 // Write the JOIN and the MODE, if any
 188                                 member->Write(line);
 189                                 if ((!mode.empty()) && (member != memb->user))
 190                                         member->Write(mode);
 191
 192                                 // Prevent the core from sending the JOIN and MODE to this user
 193                                 excepts.insert(it->first);
 194                         }
 195                 }
 196         }
 197
 198         ModResult OnSetAway(User* user, const std::string &awaymsg)
 199         {
 200                 if (awaynotify)
 201                 {
 202                         // Going away: n!u@h AWAY :reason
 203                         // Back from away: n!u@h AWAY
 204                         std::string line = ":" + user->GetFullHost() + " AWAY";
 205                         if (!awaymsg.empty())
 206                                 line += " :" + awaymsg;
 207
 208                         WriteNeighboursWithExt(user, line, cap_awaynotify.ext);
 209                 }
 210                 return MOD_RES_PASSTHRU;
 211         }
 212
 213         void OnPostJoin(Membership *memb)
 214         {
 215                 if ((!awaynotify) || (!IS_AWAY(memb->user)))
 216                         return;
 217
 218                 std::string line = ":" + memb->user->GetFullHost() + " AWAY :" + memb->user->awaymsg;
 219
 220                 const UserMembList* userlist = memb->chan->GetUsers();
 221                 for (UserMembCIter it = userlist->begin(); it != userlist->end(); ++it)
 222                 {
 223                         // Send the away notify line if the current member is local, has the away-notify cap and isn't excepted
 224                         User* member = IS_LOCAL(it->first);
 225                         if ((member) && (cap_awaynotify.ext.get(member)) && (last_excepts.find(member) == last_excepts.end()) && (it->second != memb))
 226                         {
 227                                 member->Write(line);
 228                         }
 229                 }
 230
 231                 last_excepts.clear();
 232         }
 233
 234         void Prioritize()
 235         {
 236                 ServerInstance->Modules->SetPriority(this, I_OnUserJoin, PRIORITY_LAST);
 237         }
 238
 239         Version GetVersion()
 240         {
 241                 return Version("Provides support for extended-join, away-notify and account-notify CAP capabilities", VF_VENDOR);
 242         }
 243 };
 244
 245 MODULE_INIT(ModuleIRCv3)