src/modules/m_invisible.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 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 "users.h"
  15 #include "channels.h"
  16 #include "modules.h"
  17 #include "inspircd.h"
  18
  19 /* $ModDesc: Allows for opered clients to join channels without being seen, similar to unreal 3.1 +I mode */
  20
  21 static ConfigReader* conf;
  22
  23 class QuietOper : public VisData
  24 {
  25  public:
  26         QuietOper()
  27         {
  28         }
  29
  30         virtual ~QuietOper()
  31         {
  32         }
  33
  34         virtual bool VisibleTo(userrec* user)
  35         {
  36                 return IS_OPER(user);
  37         }
  38 };
  39
  40
  41 class InvisibleMode : public ModeHandler
  42 {
  43         QuietOper* qo;
  44  public:
  45         InvisibleMode(InspIRCd* Instance) : ModeHandler(Instance, 'Q', 0, 0, false, MODETYPE_USER, true)
  46         {
  47                 qo = new QuietOper();
  48         }
  49
  50         ~InvisibleMode()
  51         {
  52                 for (user_hash::iterator i = ServerInstance->clientlist->begin(); i != ServerInstance->clientlist->end(); i++)
  53                         if (i->second->Visibility == qo)
  54                                 i->second->Visibility = NULL;
  55                 delete qo;
  56         }
  57
  58         ModeAction OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding)
  59         {
  60                 if ((source != dest) && (!*source->oper))
  61                         return MODEACTION_DENY;
  62
  63                 if (dest->IsModeSet('Q') != adding)
  64                 {
  65                         bool ok = false;
  66
  67                         for (int j = 0; j < conf->Enumerate("type"); j++)
  68                         {
  69                                 std::string opertype = conf->ReadValue("type","name",j);
  70                                 if (opertype == source->oper)
  71                                 {
  72                                         ok = conf->ReadFlag("type", "canquiet", j);
  73                                         break;
  74                                 }
  75                         }
  76
  77                         if (!ok)
  78                         {
  79                                 source->WriteServ("481 %s :Permission Denied - You do not have access to become invisible via user mode +Q", source->nick);
  80                                 return MODEACTION_DENY;
  81                         }
  82
  83                         dest->SetMode('Q', adding);
  84
  85                         /* Set visibility handler object */
  86                         dest->Visibility = adding ? qo : NULL;
  87
  88                         /* User appears to vanish or appear from nowhere */
  89                         for (UCListIter f = dest->chans.begin(); f != dest->chans.end(); f++)
  90                         {
  91                                 CUList *ulist = f->first->GetUsers();
  92                                 char tb[MAXBUF];
  93
  94                                 snprintf(tb,MAXBUF,":%s %s %s", dest->GetFullHost(), adding ? "PART" : "JOIN", f->first->name);
  95                                 std::string out = tb;
  96                                 std::string n = this->ServerInstance->Modes->ModeString(dest, f->first);
  97
  98                                 for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
  99                                 {
 100                                         /* User only appears to vanish for non-opers */
 101                                         if (IS_LOCAL(i->first) && !IS_OPER(i->first))
 102                                         {
 103                                                 i->first->Write(out);
 104                                                 if (!n.empty() && !adding)
 105                                                         i->first->WriteServ("MODE %s +%s", f->first->name, n.c_str());
 106                                         }
 107                                 }
 108
 109                                 ServerInstance->WriteOpers("*** \2NOTICE\2: Oper %s has become %svisible (%sQ)", dest->GetFullHost(), adding ? "in" : "", adding ? "+" : "-");
 110                         }
 111                         return MODEACTION_ALLOW;
 112                 }
 113                 else
 114                 {
 115                         return MODEACTION_DENY;
 116                 }
 117         }
 118 };
 119
 120 class InvisibleDeOper : public ModeWatcher
 121 {
 122  private:
 123         InspIRCd* Srv;
 124  public:
 125         InvisibleDeOper(InspIRCd* Instance) : ModeWatcher(Instance, 'o', MODETYPE_USER), Srv(Instance)
 126         {
 127         }
 128
 129         bool BeforeMode(userrec* source, userrec* dest, chanrec* channel, std::string &param, bool adding, ModeType type)
 130         {
 131                 /* Users who are opers and have +Q get their +Q removed when they deoper */
 132                 if ((!adding) && (dest->IsModeSet('Q')))
 133                 {
 134                         const char* newmodes[] = { dest->nick, "-Q" };
 135                         ServerInstance->Modes->Process(newmodes, 2, source, true);
 136                 }
 137                 return true;
 138         }
 139 };
 140
 141
 142 class ModuleInvisible : public Module
 143 {
 144  private:
 145         InvisibleMode* qm;
 146         InvisibleDeOper* ido;
 147  public:
 148         ModuleInvisible(InspIRCd* Me)
 149                 : Module::Module(Me)
 150         {
 151                 conf = new ConfigReader(ServerInstance);
 152                 qm = new InvisibleMode(ServerInstance);
 153                 if (!ServerInstance->AddMode(qm, 'Q'))
 154                         throw ModuleException("Could not add new modes!");
 155                 ido = new InvisibleDeOper(ServerInstance);
 156                 if (!ServerInstance->AddModeWatcher(ido))
 157                         throw ModuleException("Could not add new mode watcher on usermode +o!");
 158         }
 159
 160         virtual ~ModuleInvisible()
 161         {
 162                 ServerInstance->Modes->DelMode(qm);
 163                 ServerInstance->Modes->DelModeWatcher(ido);
 164                 DELETE(qm);
 165                 DELETE(ido);
 166                 DELETE(conf);
 167         }
 168
 169         virtual Version GetVersion()
 170         {
 171                 return Version(1, 1, 0, 0, VF_COMMON | VF_VENDOR, API_VERSION);
 172         }
 173
 174         void Implements(char* List)
 175         {
 176                 List[I_OnUserJoin] = List[I_OnUserPart] = List[I_OnUserQuit] = List[I_OnRehash] = 1;
 177         }
 178
 179         virtual void OnUserJoin(userrec* user, chanrec* channel, bool &silent)
 180         {
 181                 if (user->IsModeSet('Q'))
 182                 {
 183                         silent = true;
 184                         /* Because we silenced the event, make sure it reaches the user whos joining (but only them of course) */
 185                         user->WriteFrom(user, "JOIN %s", channel->name);
 186                         ServerInstance->WriteOpers("*** \2NOTICE\2: Oper %s has joined %s invisibly (+Q)", user->GetFullHost(), channel->name);
 187                 }
 188         }
 189
 190         virtual void OnRehash(userrec* user, const std::string &parameter)
 191         {
 192                 DELETE(conf);
 193                 conf = new ConfigReader(ServerInstance);
 194         }
 195
 196         void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent)
 197         {
 198                 if (user->IsModeSet('Q'))
 199                 {
 200                         silent = true;
 201                         /* Because we silenced the event, make sure it reaches the user whos leaving (but only them of course) */
 202                         user->WriteFrom(user, "PART %s%s%s", channel->name,
 203                                         partmessage.empty() ? "" : " :",
 204                                         partmessage.empty() ? "" : partmessage.c_str());
 205                 }
 206         }
 207
 208         void OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message)
 209         {
 210                 if (user->IsModeSet('Q'))
 211                 {
 212                         command_t* parthandler = ServerInstance->Parser->GetHandler("PART");
 213                         std::vector<std::string> to_leave;
 214                         const char* parameters[2];
 215                         if (parthandler)
 216                         {
 217                                 for (UCListIter f = user->chans.begin(); f != user->chans.end(); f++)
 218                                                 to_leave.push_back(f->first->name);
 219                                 /* We cant do this neatly in one loop, as we are modifying the map we are iterating */
 220                                 for (std::vector<std::string>::iterator n = to_leave.begin(); n != to_leave.end(); n++)
 221                                 {
 222                                         parameters[0] = n->c_str();
 223                                         /* This triggers our OnUserPart, above, making the PART silent */
 224                                         parthandler->Handle(parameters, 1, user);
 225                                 }
 226                         }
 227                 }
 228         }
 229 };
 230
 231 class ModuleInvisibleFactory : public ModuleFactory
 232 {
 233  public:
 234         ModuleInvisibleFactory()
 235         {
 236         }
 237
 238         ~ModuleInvisibleFactory()
 239         {
 240         }
 241
 242         virtual Module * CreateModule(InspIRCd* Me)
 243         {
 244                 return new ModuleInvisible(Me);
 245         }
 246
 247 };
 248
 249 extern "C" void * init_module( void )
 250 {
 251         return new ModuleInvisibleFactory;
 252 }
 253