src/modules/m_watch.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 using namespace std;
  18
  19 #include <stdio.h>
  20 #include <string>
  21 #include <vector>
  22 #include "users.h"
  23 #include "channels.h"
  24 #include "modules.h"
  25 #include "helperfuncs.h"
  26 #include "hashcomp.h"
  27
  28 /* $ModDesc: Provides support for the /watch command */
  29
  30 Server *Srv;
  31
  32 class watchentry
  33 {
  34  public:
  35         userrec* watcher;
  36         std::string target;
  37 };
  38
  39 typedef std::vector<watchentry> watchlist;
  40 watchlist watches;
  41
  42 class cmd_watch : public command_t
  43 {
  44  public:
  45         cmd_watch() : command_t("WATCH",0,0)
  46         {
  47                 this->source = "m_watch.so";
  48         }
  49
  50         void Handle (char **parameters, int pcnt, userrec *user)
  51         {
  52                 if (!pcnt)
  53                 {
  54                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
  55                         {
  56                                 if (q->watcher == user)
  57                                 {
  58                                         userrec* targ = Srv->FindNick(q->target);
  59                                         if (targ)
  60                                         {
  61                                                 WriteServ(user->fd,"604 %s %s %s %s %lu :is online",user->nick,targ->nick,targ->ident,targ->dhost,targ->age);
  62                                         }
  63                                 }
  64                         }
  65                         WriteServ(user->fd,"607 %s :End of WATCH list",user->nick);
  66                 }
  67                 else if (pcnt > 0)
  68                 {
  69                         for (int x = 0; x < pcnt; x++)
  70                         {
  71                                 char *nick = parameters[x];
  72                                 if (!strcasecmp(nick,"C"))
  73                                 {
  74                                         // watch clear
  75                                         bool done = false;
  76                                         while (!done)
  77                                         {
  78                                                 done = true;
  79                                                 for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
  80                                                 {
  81                                                         if (q->watcher == user)
  82                                                         {
  83                                                                 done = false;
  84                                                                 watches.erase(q);
  85                                                                 break;
  86                                                         }
  87                                                 }
  88                                         }
  89                                 }
  90                                 else if (!strcasecmp(nick,"L"))
  91                                 {
  92                                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
  93                                         {
  94                                                 if (q->watcher == user)
  95                                                 {
  96                                                         userrec* targ = Srv->FindNick(q->target);
  97                                                         if (targ)
  98                                                         {
  99                                                                 WriteServ(user->fd,"604 %s %s %s %s %lu :is online",user->nick,targ->nick,targ->ident,targ->dhost,targ->age);
 100                                                         }
 101                                                 }
 102                                         }
 103                                         WriteServ(user->fd,"607 %s :End of WATCH list",user->nick);
 104                                 }
 105                                 else if (!strcasecmp(nick,"S"))
 106                                 {
 107                                         std::string list = "";
 108                                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 109                                         {
 110                                                 if (q->watcher == user)
 111                                                 {
 112                                                         list = list + " " + q->target;
 113                                                 }
 114                                         }
 115                                         char* l = (char*)list.c_str();
 116                                         if (*l == ' ')
 117                                                 l++;
 118                                         WriteServ(user->fd,"606 %s :%s",user->nick,l);
 119                                         WriteServ(user->fd,"607 %s :End of WATCH S",user->nick);
 120                                 }
 121                                 else if (nick[0] == '-')
 122                                 {
 123                                         // removing an item from the list
 124                                         nick++;
 125                                         irc::string n1 = nick;
 126                                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 127                                         {
 128                                                 if (q->watcher == user)
 129                                                 {
 130                                                         irc::string n2 = q->target.c_str();
 131                                                         userrec* a = Srv->FindNick(q->target);
 132                                                         if (a)
 133                                                         {
 134                                                                 WriteServ(user->fd,"602 %s %s %s %s %lu :stopped watching",user->nick,a->nick,a->ident,a->dhost,a->age);
 135                                                         }
 136                                                         else
 137                                                         {
 138                                                                  WriteServ(user->fd,"602 %s %s * * 0 :stopped watching",user->nick,q->target.c_str());
 139                                                         }
 140                                                         if (n1 == n2)
 141                                                         {
 142                                                                 watches.erase(q);
 143                                                                 break;
 144                                                         }
 145                                                 }
 146                                         }
 147                                 }
 148                                 else if (nick[0] == '+')
 149                                 {
 150                                         nick++;
 151                                         irc::string n1 = nick;
 152                                         bool exists = false;
 153                                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 154                                         {
 155                                                 if (q->watcher == user)
 156                                                 {
 157                                                         irc::string n2 = q->target.c_str();
 158                                                         if (n1 == n2)
 159                                                         {
 160                                                                 // already on watch list
 161                                                                 exists = true;
 162                                                         }
 163                                                 }
 164                                         }
 165                                         if (!exists)
 166                                         {
 167                                                 watchentry w;
 168                                                 w.watcher = user;
 169                                                 w.target = nick;
 170                                                 watches.push_back(w);
 171                                                 log(DEBUG,"*** Added %s to watchlist of %s",nick,user->nick);
 172                                         }
 173                                         userrec* a = Srv->FindNick(nick);
 174                                         if (a)
 175                                         {
 176                                                 WriteServ(user->fd,"604 %s %s %s %s %lu :is online",user->nick,a->nick,a->ident,a->dhost,a->age);
 177                                         }
 178                                         else
 179                                         {
 180                                                 WriteServ(user->fd,"605 %s %s * * 0 :is offline",user->nick,nick);
 181                                         }
 182                                 }
 183                         }
 184                 }
 185                 return;
 186         }
 187 };
 188
 189 class Modulewatch : public Module
 190 {
 191         cmd_watch* mycommand;
 192  public:
 193
 194         Modulewatch(Server* Me)
 195                 : Module::Module(Me)
 196         {
 197                 Srv = Me;
 198                 mycommand = new cmd_watch();
 199                 Srv->AddCommand(mycommand);
 200         }
 201
 202         virtual void OnUserQuit(userrec* user, std::string reason)
 203         {
 204                 log(DEBUG,"*** WATCH: On global quit: user %s",user->nick);
 205                 irc::string n2 = user->nick;
 206                 for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 207                 {
 208                         irc::string n1 = q->target.c_str();
 209                         if (n1 == n2)
 210                         {
 211                                 log(DEBUG,"*** WATCH: On global quit: user %s is in notify of %s",user->nick,q->watcher->nick);
 212                                 WriteServ(q->watcher->fd,"601 %s %s %s %s %lu :went offline",q->watcher->nick,user->nick,user->ident,user->dhost,time(NULL));
 213                         }
 214                 }
 215                 bool done = false;
 216                 while (!done)
 217                 {
 218                         done = true;
 219                         for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 220                         {
 221                                 if (q->watcher == user)
 222                                 {
 223                                         done = false;
 224                                         watches.erase(q);
 225                                         break;
 226                                 }
 227                         }
 228                 }
 229         }
 230
 231         virtual void OnGlobalConnect(userrec* user)
 232         {
 233                 irc::string n2 = user->nick;
 234                 log(DEBUG,"*** WATCH: On global connect: user %s",user->nick);
 235                 for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 236                 {
 237                         irc::string n1 = q->target.c_str();
 238                         if (n1 == n2)
 239                         {
 240                                 log(DEBUG,"*** WATCH: On global connect: user %s is in notify of %s",user->nick,q->watcher->nick);
 241                                 WriteServ(q->watcher->fd,"600 %s %s %s %s %lu :arrived online",q->watcher->nick,user->nick,user->ident,user->dhost,user->age);
 242                         }
 243                 }
 244         }
 245
 246         virtual void OnUserPostNick(userrec* user, std::string oldnick)
 247         {
 248                 irc::string n2 = oldnick.c_str();
 249                 irc::string n3 = user->nick;
 250                 log(DEBUG,"*** WATCH: On global nickchange: old nick: %s new nick: %s",oldnick.c_str(),user->nick);
 251                 for (watchlist::iterator q = watches.begin(); q != watches.end(); q++)
 252                 {
 253                         irc::string n1 = q->target.c_str();
 254                         // changed from a nick on the watchlist to one that isnt
 255                         if (n1 == n2)
 256                         {
 257                                 log(DEBUG,"*** WATCH: On global nickchange: old nick %s was on notify list of %s",oldnick.c_str(),q->watcher->nick);
 258                                 WriteServ(q->watcher->fd,"601 %s %s %s %s %lu :went offline",q->watcher->nick,oldnick.c_str(),user->ident,user->dhost,time(NULL));
 259                         }
 260                         else if (n1 == n3)
 261                         {
 262                                 // changed from a nick not on notify to one that is
 263                                 log(DEBUG,"*** WATCH: On global nickchange: new nick %s is on notify list of %s",user->nick,q->watcher->nick);
 264                                 WriteServ(q->watcher->fd,"600 %s %s %s %s %lu :arrived online",q->watcher->nick,user->nick,user->ident,user->dhost,user->age);
 265                         }
 266                 }
 267         }
 268
 269         virtual void On005Numeric(std::string &output)
 270         {
 271                 // we don't really have a limit...
 272                 output = output + " WATCH=999";
 273         }
 274
 275         virtual ~Modulewatch()
 276         {
 277         }
 278
 279         virtual Version GetVersion()
 280         {
 281                 return Version(1,0,0,1,VF_VENDOR);
 282         }
 283 };
 284
 285
 286 class ModulewatchFactory : public ModuleFactory
 287 {
 288  public:
 289         ModulewatchFactory()
 290         {
 291         }
 292
 293         ~ModulewatchFactory()
 294         {
 295         }
 296
 297         virtual Module * CreateModule(Server* Me)
 298         {
 299                 return new Modulewatch(Me);
 300         }
 301
 302 };
 303
 304
 305 extern "C" void * init_module( void )
 306 {
 307         return new ModulewatchFactory;
 308 }
 309