src/modules/m_callerid.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include <set>
  16 #include <sstream>
  17 #include <algorithm>
  18
  19 /* $ModDesc: Implementation of callerid (umode +g & /accept, ala hybrid etc) */
  20
  21 class callerid_data : public classbase
  22 {
  23  public:
  24         time_t lastnotify;
  25         std::set<User*> accepting;
  26
  27         callerid_data() : lastnotify(0) { }
  28         callerid_data(const std::string& str, InspIRCd* ServerInstance)
  29         {
  30                 irc::commasepstream s(str);
  31                 std::string tok;
  32                 if (s.GetToken(tok))
  33                 {
  34                         lastnotify = ConvToInt(tok);
  35                 }
  36                 while (s.GetToken(tok))
  37                 {
  38                         if (tok.empty())
  39                         {
  40                                 continue;
  41                         }
  42                         User* u = ServerInstance->FindUUID(tok);
  43                         if (!u)
  44                         {
  45                                 u = ServerInstance->FindNick(tok);
  46                         }
  47                         if (!u)
  48                         {
  49                                 continue;
  50                         }
  51                         accepting.insert(u);
  52                 }
  53         }
  54
  55         std::string ToString(bool displayable) const
  56         {
  57                 std::ostringstream oss;
  58                 oss << lastnotify;
  59                 for (std::set<User*>::const_iterator i = accepting.begin(); i != accepting.end(); ++i)
  60                 {
  61                         // Encode UIDs.
  62                         oss << "," << (displayable ? (*i)->nick : (*i)->uuid);
  63                 }
  64                 oss << std::ends;
  65                 return oss.str();
  66         }
  67 };
  68
  69 callerid_data* GetData(User* who, bool extend = true)
  70 {
  71         callerid_data* dat;
  72         if (who->GetExt("callerid_data", dat))
  73                 return dat;
  74         else
  75         {
  76                 if (extend)
  77                 {
  78                         dat = new callerid_data;
  79                         who->Extend("callerid_data", dat);
  80                         return dat;
  81                 }
  82                 else
  83                         return NULL;
  84         }
  85 }
  86
  87 void RemoveData(User* who)
  88 {
  89         callerid_data* dat;
  90         who->GetExt("callerid_data", dat);
  91
  92         if (!dat)
  93                 return;
  94
  95         who->Shrink("callerid_data");
  96         delete dat;
  97 }
  98
  99 void RemoveFromAllAccepts(InspIRCd* ServerInstance, User* who)
 100 {
 101         for (user_hash::iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end(); ++i)
 102         {
 103                 callerid_data* dat = GetData(i->second, false);
 104
 105                 if (!dat)
 106                         continue;
 107
 108                 std::set<User*>::iterator iter = dat->accepting.find(who);
 109
 110                 if (iter == dat->accepting.end())
 111                         continue;
 112
 113                 dat->accepting.erase(iter);
 114         }
 115 }
 116
 117 class User_g : public SimpleUserModeHandler
 118 {
 119 public:
 120         User_g(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'g') { }
 121 };
 122
 123 class CommandAccept : public Command
 124 {
 125 private:
 126         unsigned int& maxaccepts;
 127 public:
 128         CommandAccept(InspIRCd* Instance, unsigned int& max) : Command(Instance, "ACCEPT", 0, 1), maxaccepts(max)
 129         {
 130                 source = "m_callerid.so";
 131                 syntax = "{[+|-]<nicks>}|*}";
 132                 TRANSLATE2(TR_CUSTOM, TR_END);
 133         }
 134
 135         virtual void EncodeParameter(std::string& parameter, int index)
 136         {
 137                 if (index != 0)
 138                         return;
 139                 std::string out = "";
 140                 irc::commasepstream nicks(parameter);
 141                 std::string tok;
 142                 while (nicks.GetToken(tok))
 143                 {
 144                         if (tok == "*")
 145                         {
 146                                 continue; // Drop list requests, since remote servers ignore them anyway.
 147                         }
 148                         if (!out.empty())
 149                                 out.append(",");
 150                         bool dash = false;
 151                         if (tok[0] == '-')
 152                         {
 153                                 dash = true;
 154                                 tok.erase(0, 1); // Remove the dash.
 155                         }
 156                         User* u = ServerInstance->FindNick(tok);
 157                         if (u)
 158                         {
 159                                 if (dash)
 160                                         out.append("-");
 161                                 out.append(u->uuid);
 162                         }
 163                         else
 164                         {
 165                                 if (dash)
 166                                         out.append("-");
 167                                 out.append(tok);
 168                         }
 169                 }
 170                 parameter = out;
 171         }
 172
 173         /** Will take any number of nicks (up to MaxTargets), which can be seperated by commas.
 174          * - in front of any nick removes, and an * lists. This effectively means you can do:
 175          * /accept nick1,nick2,nick3,*
 176          * to add 3 nicks and then show your list
 177          */
 178         CmdResult Handle(const std::vector<std::string> &parameters, User* user)
 179         {
 180                 if (ServerInstance->Parser->LoopCall(user, this, parameters, 0))
 181                         return CMD_SUCCESS;
 182                 /* Even if callerid mode is not set, we let them manage their ACCEPT list so that if they go +g they can
 183                  * have a list already setup. */
 184
 185                 std::string tok = parameters[0];
 186
 187                 if (tok == "*")
 188                 {
 189                         if (IS_LOCAL(user))
 190                                 ListAccept(user);
 191                         return CMD_LOCALONLY;
 192                 }
 193                 else if (tok[0] == '-')
 194                 {
 195                         User* whotoremove = ServerInstance->FindNick(tok.substr(1));
 196                         if (whotoremove)
 197                                 return (RemoveAccept(user, whotoremove, false) ? CMD_SUCCESS : CMD_FAILURE);
 198                         else
 199                                 return CMD_FAILURE;
 200                 }
 201                 else
 202                 {
 203                         User* whotoadd = ServerInstance->FindNick(tok[0] == '+' ? tok.substr(1) : tok);
 204                         if (whotoadd)
 205                                 return (AddAccept(user, whotoadd, false) ? CMD_SUCCESS : CMD_FAILURE);
 206                         else
 207                         {
 208                                 user->WriteNumeric(401, "%s %s :No such nick/channel", user->nick.c_str(), tok.c_str());
 209                                 return CMD_FAILURE;
 210                         }
 211                 }
 212         }
 213
 214         void ListAccept(User* user)
 215         {
 216                 callerid_data* dat = GetData(user, false);
 217                 if (dat)
 218                 {
 219                         for (std::set<User*>::iterator i = dat->accepting.begin(); i != dat->accepting.end(); ++i)
 220                                 user->WriteNumeric(281, "%s %s", user->nick.c_str(), (*i)->nick.c_str());
 221                 }
 222                 user->WriteNumeric(282, "%s :End of ACCEPT list", user->nick.c_str());
 223         }
 224
 225         bool AddAccept(User* user, User* whotoadd, bool quiet)
 226         {
 227                 callerid_data* dat = GetData(user, true);
 228                 if (dat->accepting.size() >= maxaccepts)
 229                 {
 230                         if (!quiet)
 231                                 user->WriteNumeric(456, "%s :Accept list is full (limit is %d)", user->nick.c_str(), maxaccepts);
 232
 233                         return false;
 234                 }
 235                 if (!dat->accepting.insert(whotoadd).second)
 236                 {
 237                         if (!quiet)
 238                                 user->WriteNumeric(457, "%s %s :is already on your accept list", user->nick.c_str(), whotoadd->nick.c_str());
 239
 240                         return false;
 241                 }
 242                 return true;
 243         }
 244
 245         bool RemoveAccept(User* user, User* whotoremove, bool quiet)
 246         {
 247                 callerid_data* dat = GetData(user, false);
 248                 if (!dat)
 249                 {
 250                         if (!quiet)
 251                                 user->WriteNumeric(458, "%s %s :is not on your accept list", user->nick.c_str(), whotoremove->nick.c_str());
 252
 253                         return false;
 254                 }
 255                 std::set<User*>::iterator i = dat->accepting.find(whotoremove);
 256                 if (i == dat->accepting.end())
 257                 {
 258                         if (!quiet)
 259                                 user->WriteNumeric(458, "%s %s :is not on your accept list", user->nick.c_str(), whotoremove->nick.c_str());
 260
 261                         return false;
 262                 }
 263                 dat->accepting.erase(i);
 264                 return true;
 265         }
 266 };
 267
 268 class ModuleCallerID : public Module
 269 {
 270 private:
 271         CommandAccept *mycommand;
 272         User_g* myumode;
 273
 274         // Configuration variables:
 275         unsigned int maxaccepts; // Maximum ACCEPT entries.
 276         bool operoverride; // Operators can override callerid.
 277         bool tracknick; // Allow ACCEPT entries to update with nick changes.
 278         unsigned int notify_cooldown; // Seconds between notifications.
 279
 280 public:
 281         ModuleCallerID(InspIRCd* Me) : Module(Me)
 282         {
 283                 OnRehash(NULL, "");
 284                 mycommand = new CommandAccept(ServerInstance, maxaccepts);
 285                 myumode = new User_g(ServerInstance);
 286
 287                 if (!ServerInstance->Modes->AddMode(myumode))
 288                 {
 289                         delete mycommand;
 290                         delete myumode;
 291                         throw ModuleException("Could not add usermode +g");
 292                 }
 293                 try
 294                 {
 295                         ServerInstance->AddCommand(mycommand);
 296                 }
 297                 catch (const ModuleException& e)
 298                 {
 299                         delete mycommand;
 300                         delete myumode;
 301                         throw ModuleException("Could not add command!");
 302                 }
 303
 304                 Implementation eventlist[] = { I_OnRehash, I_OnUserPreNick, I_OnUserQuit, I_On005Numeric, I_OnUserPreNotice, I_OnUserPreMessage, I_OnCleanup };
 305                 ServerInstance->Modules->Attach(eventlist, this, 7);
 306         }
 307
 308         virtual ~ModuleCallerID()
 309         {
 310                 ServerInstance->Modes->DelMode(myumode);
 311                 delete myumode;
 312         }
 313
 314         virtual Version GetVersion()
 315         {
 316                 return Version("$Id$", VF_COMMON | VF_VENDOR, API_VERSION);
 317         }
 318
 319         virtual void On005Numeric(std::string& output)
 320         {
 321                 output += " CALLERID=g";
 322         }
 323
 324         int PreText(User* user, User* dest, std::string& text, bool notice)
 325         {
 326                 if (!dest->IsModeSet('g'))
 327                         return 0;
 328
 329                 if (operoverride && IS_OPER(user))
 330                         return 0;
 331
 332                 callerid_data* dat = GetData(dest, true);
 333                 std::set<User*>::iterator i = dat->accepting.find(dest);
 334
 335                 if (i == dat->accepting.end())
 336                 {
 337                         time_t now = time(NULL);
 338                         /* +g and *not* accepted */
 339                         user->WriteNumeric(716, "%s %s :is in +g mode (server-side ignore).", user->nick.c_str(), dest->nick.c_str());
 340                         if (now > (dat->lastnotify + (time_t)notify_cooldown))
 341                         {
 342                                 user->WriteNumeric(717, "%s %s :has been informed that you messaged them.", user->nick.c_str(), dest->nick.c_str());
 343                                 dest->WriteNumeric(718, "%s %s %s@%s :is messaging you, and you have umode +g", dest->nick.c_str(), user->nick.c_str(), user->ident.c_str(), user->dhost.c_str());
 344                                 dat->lastnotify = now;
 345                         }
 346                         return 1;
 347                 }
 348                 return 0;
 349         }
 350
 351         virtual int OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList &exempt_list)
 352         {
 353                 if (IS_LOCAL(user) && target_type == TYPE_USER)
 354                         return PreText(user, (User*)dest, text, true);
 355
 356                 return 0;
 357         }
 358
 359         virtual int OnUserPreNotice(User* user, void* dest, int target_type, std::string& text, char status, CUList &exempt_list)
 360         {
 361                 if (IS_LOCAL(user) && target_type == TYPE_USER)
 362                         return PreText(user, (User*)dest, text, true);
 363
 364                 return 0;
 365         }
 366
 367         virtual void OnCleanup(int type, void* item)
 368         {
 369                 if (type != TYPE_USER)
 370                         return;
 371
 372                 User* u = (User*)item;
 373                 /* Cleanup only happens on unload (before dtor), so keep this O(n) instead of O(n^2) which deferring to OnUserQuit would do.  */
 374                 RemoveData(u);
 375         }
 376
 377         virtual void OnSyncUserMetaData(User* user, Module* proto, void* opaque, const std::string& extname, bool displayable)
 378         {
 379                 if (extname == "callerid_data")
 380                 {
 381                         callerid_data* dat = GetData(user, false);
 382                         if (dat)
 383                         {
 384                                 std::string str = dat->ToString(displayable);
 385                                 proto->ProtoSendMetaData(opaque, TYPE_USER, user, extname, str);
 386                         }
 387                 }
 388         }
 389
 390         virtual void OnDecodeMetaData(int target_type, void* target, const std::string& extname, const std::string& extdata)
 391         {
 392                 if (target_type == TYPE_USER && extname == "callerid_data")
 393                 {
 394                         User* u = (User*)target;
 395                         callerid_data* dat = new callerid_data(extdata, ServerInstance);
 396                         u->Extend("callerid_data", dat);
 397                 }
 398         }
 399
 400         virtual int OnUserPreNick(User* user, const std::string& newnick)
 401         {
 402                 if (!tracknick)
 403                         RemoveFromAllAccepts(ServerInstance, user);
 404                 return 0;
 405         }
 406
 407         virtual void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
 408         {
 409                 RemoveData(user);
 410                 RemoveFromAllAccepts(ServerInstance, user);
 411         }
 412
 413         virtual void OnRehash(User* user, const std::string& parameter)
 414         {
 415                 ConfigReader Conf(ServerInstance);
 416                 maxaccepts = Conf.ReadInteger("callerid", "maxaccepts", "16", 0, true);
 417                 operoverride = Conf.ReadFlag("callerid", "operoverride", "0", 0);
 418                 tracknick = Conf.ReadFlag("callerid", "tracknick", "0", 0);
 419                 notify_cooldown = Conf.ReadInteger("callerid", "cooldown", "60", 0, true);
 420         }
 421 };
 422
 423 MODULE_INIT(ModuleCallerID)
 424
 425