src/modules/m_nicklock.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 <stdio.h>
  15 #include <string>
  16 #include "users.h"
  17 #include "channels.h"
  18 #include "modules.h"
  19
  20 #include "hashcomp.h"
  21 #include "inspircd.h"
  22
  23 /* $ModDesc: Provides the NICKLOCK command, allows an oper to chage a users nick and lock them to it until they quit */
  24
  25
  26 /** Handle /NICKLOCK
  27  */
  28 class cmd_nicklock : public command_t
  29 {
  30         char* dummy;
  31  public:
  32  cmd_nicklock (InspIRCd* Instance) : command_t(Instance,"NICKLOCK", 'o', 2)
  33         {
  34                 this->source = "m_nicklock.so";
  35                 syntax = "<oldnick> <newnick>";
  36         }
  37
  38         CmdResult Handle(const char** parameters, int pcnt, userrec *user)
  39         {
  40                 userrec* source = ServerInstance->FindNick(parameters[0]);
  41                 irc::string server;
  42                 irc::string me;
  43
  44                 // check user exists
  45                 if (!source)
  46                 {
  47                         return CMD_FAILURE;
  48                 }
  49
  50                 // check if user is locked
  51                 if (source->GetExt("nick_locked", dummy))
  52                 {
  53                         user->WriteServ("946 %s %s :This user's nickname is already locked.",user->nick,source->nick);
  54                         return CMD_FAILURE;
  55                 }
  56
  57                 // check nick is valid
  58                 if (!ServerInstance->IsNick(parameters[1]))
  59                 {
  60                         return CMD_FAILURE;
  61                 }
  62
  63                 // let others know
  64                 ServerInstance->WriteOpers(std::string(user->nick)+" used NICKLOCK to change and hold "+parameters[0]+" to "+parameters[1]);
  65
  66                 if (!source->ForceNickChange(parameters[1]))
  67                 {
  68                         // ugh, nickchange failed for some reason -- possibly existing nick?
  69                         userrec::QuitUser(ServerInstance, source, "Nickname collision");
  70                         return CMD_FAILURE;
  71                 }
  72
  73                 // give them a lock flag
  74                 source->Extend("nick_locked", "ON");
  75
  76                 /* route */
  77                 return CMD_SUCCESS;
  78         }
  79 };
  80
  81 /** Handle /NICKUNLOCK
  82  */
  83 class cmd_nickunlock : public command_t
  84 {
  85  public:
  86  cmd_nickunlock (InspIRCd* Instance) : command_t(Instance,"NICKUNLOCK", 'o', 1)
  87         {
  88                 this->source = "m_nickunlock.so";
  89                 syntax = "<locked-nick>";
  90         }
  91
  92         CmdResult Handle (const char** parameters, int pcnt, userrec *user)
  93         {
  94                 userrec* source = ServerInstance->FindNick(parameters[0]);
  95                 if (source)
  96                 {
  97                         source->Shrink("nick_locked");
  98                         user->WriteServ("945 %s %s :Nickname now unlocked.",user->nick,source->nick);
  99                         ServerInstance->WriteOpers(std::string(user->nick)+" used NICKUNLOCK on "+parameters[0]);
 100                         return CMD_SUCCESS;
 101                 }
 102
 103                 return CMD_FAILURE;
 104         }
 105 };
 106
 107
 108 class ModuleNickLock : public Module
 109 {
 110         cmd_nicklock*   cmd1;
 111         cmd_nickunlock* cmd2;
 112         char* n;
 113  public:
 114         ModuleNickLock(InspIRCd* Me)
 115                 : Module(Me)
 116         {
 117
 118                 cmd1 = new cmd_nicklock(ServerInstance);
 119                 cmd2 = new cmd_nickunlock(ServerInstance);
 120                 ServerInstance->AddCommand(cmd1);
 121                 ServerInstance->AddCommand(cmd2);
 122         }
 123
 124         virtual ~ModuleNickLock()
 125         {
 126         }
 127
 128         virtual Version GetVersion()
 129         {
 130                 return Version(1,1,0,1,VF_VENDOR,API_VERSION);
 131         }
 132
 133         void Implements(char* List)
 134         {
 135                 List[I_OnUserPreNick] = List[I_OnUserQuit] = List[I_OnCleanup] = 1;
 136         }
 137
 138         virtual int OnUserPreNick(userrec* user, const std::string &newnick)
 139         {
 140                 if (user->GetExt("nick_locked", n))
 141                 {
 142                         user->WriteServ("447 %s :You cannot change your nickname (your nick is locked)",user->nick);
 143                         return 1;
 144                 }
 145                 return 0;
 146         }
 147
 148         virtual void OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message)
 149         {
 150                 user->Shrink("nick_locked");
 151         }
 152
 153         virtual void OnCleanup(int target_type, void* item)
 154         {
 155                 if(target_type == TYPE_USER)
 156                 {
 157                         userrec* user = (userrec*)item;
 158                         user->Shrink("nick_locked");
 159                 }
 160         }
 161 };
 162
 163 // stuff down here is the module-factory stuff. For basic modules you can ignore this.
 164
 165 class ModuleNickLockFactory : public ModuleFactory
 166 {
 167  public:
 168         ModuleNickLockFactory()
 169         {
 170         }
 171
 172         ~ModuleNickLockFactory()
 173         {
 174         }
 175
 176         virtual Module * CreateModule(InspIRCd* Me)
 177         {
 178                 return new ModuleNickLock(Me);
 179         }
 180
 181 };
 182
 183
 184 extern "C" DllExport void * init_module( void )
 185 {
 186         return new ModuleNickLockFactory;
 187 }
 188