src/modules/m_knock.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 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 "users.h"
  22 #include "channels.h"
  23 #include "modules.h"
  24 #include "helperfuncs.h"
  25
  26 /* $ModDesc: Provides support for /KNOCK and mode +K */
  27
  28 static Server *Srv;
  29
  30 class cmd_knock : public command_t
  31 {
  32  public:
  33         cmd_knock () : command_t("KNOCK", 0, 2)
  34         {
  35                 this->source = "m_knock.so";
  36         }
  37
  38         void Handle (char **parameters, int pcnt, userrec *user)
  39         {
  40                 chanrec* c = Srv->FindChannel(parameters[0]);
  41
  42                 if (!c)
  43                 {
  44                         WriteServ(user->fd,"401 %s %s :No such channel",user->nick, parameters[0]);
  45                         return;
  46                 }
  47
  48                 std::string line = "";
  49
  50                 if (c->IsModeSet('K'))
  51                 {
  52                         WriteServ(user->fd,"480 %s :Can't KNOCK on %s, +K is set.",user->nick, c->name);
  53                         return;
  54                 }
  55
  56                 for (int i = 1; i < pcnt - 1; i++)
  57                 {
  58                         line = line + std::string(parameters[i]) + " ";
  59                 }
  60                 line = line + std::string(parameters[pcnt-1]);
  61
  62                 if (c->modes[CM_INVITEONLY])
  63                 {
  64                         WriteChannelWithServ((char*)Srv->GetServerName().c_str(),c,"NOTICE %s :User %s is KNOCKing on %s (%s)",c->name,user->nick,c->name,line.c_str());
  65                         WriteServ(user->fd,"NOTICE %s :KNOCKing on %s",user->nick,c->name);
  66                         return;
  67                 }
  68                 else
  69                 {
  70                         WriteServ(user->fd,"480 %s :Can't KNOCK on %s, channel is not invite only so knocking is pointless!",user->nick, c->name);
  71                         return;
  72                 }
  73         }
  74 };
  75
  76 class ModuleKnock : public Module
  77 {
  78         cmd_knock* mycommand;
  79  public:
  80         ModuleKnock(Server* Me)
  81                 : Module::Module(Me)
  82         {
  83                 Srv = Me;
  84                 Srv->AddExtendedMode('K',MT_CHANNEL,false,0,0);
  85                 mycommand = new cmd_knock();
  86                 Srv->AddCommand(mycommand);
  87         }
  88
  89         void Implements(char* List)
  90         {
  91                 List[I_On005Numeric] = List[I_OnExtendedMode] = 1;
  92         }
  93
  94         virtual void On005Numeric(std::string &output)
  95         {
  96                 InsertMode(output,"K",4);
  97         }
  98
  99         virtual ~ModuleKnock()
 100         {
 101         }
 102
 103         virtual Version GetVersion()
 104         {
 105                 return Version(1,0,0,1,VF_STATIC|VF_VENDOR);
 106         }
 107
 108         virtual int OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params)
 109         {
 110                 // check if this is our mode character...
 111                 if ((modechar == 'K') && (type == MT_CHANNEL))
 112                 {
 113                         return 1;
 114                 }
 115                 else
 116                 {
 117                         return 0;
 118                 }
 119         }
 120
 121 };
 122
 123 // stuff down here is the module-factory stuff. For basic modules you can ignore this.
 124
 125 class ModuleKnockFactory : public ModuleFactory
 126 {
 127  public:
 128         ModuleKnockFactory()
 129         {
 130         }
 131
 132         ~ModuleKnockFactory()
 133         {
 134         }
 135
 136         virtual Module * CreateModule(Server* Me)
 137         {
 138                 return new ModuleKnock(Me);
 139         }
 140
 141 };
 142
 143
 144 extern "C" void * init_module( void )
 145 {
 146         return new ModuleKnockFactory;
 147 }
 148