src/modules/m_lockserv.cpp

   1 #include "users.h"
   2 #include "channels.h"
   3 #include "modules.h"
   4 #include "inspircd.h"
   5
   6
   7 /* $ModDesc: Allows locking of the server to stop all incoming connections till unlocked again */
   8
   9 /** Adds numerics
  10  * 988 <nick> <servername> :Closed for new connections\r
  11  * 989 <nick> <servername> :Open for new connections
  12 */
  13
  14
  15 class cmd_lockserv : public command_t
  16 {
  17 private:
  18         bool& locked;
  19
  20 public:
  21         cmd_lockserv (InspIRCd* Instance, bool &lock)
  22         : command_t(Instance, "LOCKSERV", 'o', 0), locked(lock)
  23         {
  24                 this->source = "m_lockserv.so";
  25                 syntax = "";
  26         }
  27
  28         CmdResult Handle (const char** parameters, int pcnt, userrec *user)
  29         {
  30                 locked = true;
  31                 user->WriteServ("988 %s %s :Closed for new connections", user->nick, user->server);
  32                 ServerInstance->WriteOpers("*** Oper %s used LOCKSERV to temporarily close for new connections", user->nick);
  33                 /* Dont send to the network */
  34                 return CMD_LOCALONLY;
  35         }
  36 };
  37
  38 class cmd_unlockserv : public command_t
  39 {
  40 private:
  41         bool& locked;
  42
  43 public:
  44         cmd_unlockserv (InspIRCd* Instance, bool &lock)
  45         : command_t(Instance, "UNLOCKSERV", 'o', 0), locked(lock)
  46         {
  47                 this->source = "m_lockserv.so";
  48                 syntax = "";
  49         }
  50
  51         CmdResult Handle (const char** parameters, int pcnt, userrec *user)
  52         {
  53                 locked = false;
  54                 user->WriteServ("989 %s %s :Open for new connections", user->nick, user->server);
  55                 ServerInstance->WriteOpers("*** Oper %s used UNLOCKSERV to allow for new connections", user->nick);
  56                 /* Dont send to the network */
  57                 return CMD_LOCALONLY;
  58         }
  59 };
  60
  61 class ModuleLockserv : public Module
  62 {
  63 private:
  64         bool locked;
  65         cmd_lockserv* lockcommand;
  66         cmd_unlockserv* unlockcommand;
  67
  68         virtual void ResetLocked()
  69         {
  70                 locked = false;
  71         }
  72
  73 public:
  74         ModuleLockserv(InspIRCd* Me) : Module::Module(Me)
  75         {
  76                 ResetLocked();
  77                 lockcommand = new cmd_lockserv(ServerInstance, locked);
  78                 ServerInstance->AddCommand(lockcommand);
  79
  80                 unlockcommand = new cmd_unlockserv(ServerInstance, locked);
  81                 ServerInstance->AddCommand(unlockcommand);
  82         }
  83
  84     virtual ~ModuleLockserv()
  85     {
  86     }
  87
  88         void Implements(char* List)
  89         {
  90                 List[I_OnUserRegister] = List[I_OnRehash] = List[I_OnCheckReady] = 1;
  91         }
  92
  93         virtual void OnRehash(const std::string &parameter)
  94         {
  95                 ResetLocked();
  96         }
  97
  98         virtual int OnUserRegister(userrec* user)
  99     {
 100                 if (locked)
 101                 {
 102                         userrec::QuitUser(ServerInstance, user, "Server is temporarily closed. Please try again later.");
 103                         return 1;
 104                 }
 105                 return 0;
 106         }
 107
 108         virtual bool OnCheckReady(userrec* user)
 109         {
 110                 return !locked;
 111         }
 112
 113         virtual Version GetVersion()
 114         {
 115                 return Version(1,0,0,1,0, API_VERSION);
 116         }
 117 };
 118
 119 class ModuleLockservFactory : public ModuleFactory
 120 {
 121 public:
 122         ModuleLockservFactory()
 123         {
 124         }
 125
 126         ~ModuleLockservFactory()
 127         {
 128         }
 129
 130         virtual Module * CreateModule(InspIRCd* Me)
 131         {
 132                 return new ModuleLockserv(Me);
 133         }
 134 };
 135
 136 extern "C" void * init_module( void )
 137 {
 138         return new ModuleLockservFactory;
 139 }