src/modules/m_sslmodes.cpp

   1 #include "users.h"
   2 #include "channels.h"
   3 #include "modules.h"
   4 #include "helperfuncs.h"
   5 #include "inspircd.h"
   6
   7 /* $ModDesc: Provides support for unreal-style channel mode +z */
   8
   9 static char* dummy;
  10
  11 extern InspIRCd* ServerInstance;
  12
  13 class SSLMode : public ModeHandler
  14 {
  15         Server* Srv;
  16  public:
  17         SSLMode(Server* s) : ModeHandler('z', 0, 0, false, MODETYPE_CHANNEL, false), Srv(s) { }
  18
  19         ModeAction OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding)
  20         {
  21                 if (adding)
  22                 {
  23                         if (!channel->IsModeSet('z'))
  24                         {
  25                                 if (IS_LOCAL(source))
  26                                 {
  27                                         CUList* userlist = channel->GetUsers();
  28                                         for(CUList::iterator i = userlist->begin(); i != userlist->end(); i++)
  29                                         {
  30                                                 if(!i->second->GetExt("ssl", dummy))
  31                                                 {
  32                                                         source->WriteServ("490 %s %s :all members of the channel must be connected via SSL", source->nick, channel->name);
  33                                                         return MODEACTION_DENY;
  34                                                 }
  35                                         }
  36                                 }
  37                                 channel->SetMode('z',true);
  38                                 return MODEACTION_ALLOW;
  39                         }
  40                         else
  41                         {
  42                                 return MODEACTION_DENY;
  43                         }
  44                 }
  45                 else
  46                 {
  47                         if (channel->IsModeSet('z'))
  48                         {
  49                                 channel->SetMode('z',false);
  50                                 return MODEACTION_ALLOW;
  51                         }
  52
  53                         return MODEACTION_DENY;
  54                 }
  55         }
  56 };
  57
  58 class ModuleSSLModes : public Module
  59 {
  60         Server *Srv;
  61         SSLMode* sslm;
  62
  63  public:
  64         ModuleSSLModes(Server* Me)
  65                 : Module::Module(Me)
  66         {
  67                 Srv = Me;
  68
  69                 sslm = new SSLMode(Me);
  70                 Srv->AddMode(sslm, 'z');
  71         }
  72
  73         void Implements(char* List)
  74         {
  75                 List[I_On005Numeric] = List[I_OnUserPreJoin] = 1;
  76         }
  77
  78         virtual void On005Numeric(std::string &output)
  79         {
  80                 ServerInstance->ModeGrok->InsertMode(output, "z", 4);
  81         }
  82
  83         virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname)
  84         {
  85                 if(chan && chan->IsModeSet('z'))
  86                 {
  87                         if(user->GetExt("ssl", dummy))
  88                         {
  89                                 // Let them in
  90                                 return 0;
  91                         }
  92                         else
  93                         {
  94                                 // Deny
  95                                 user->WriteServ( "489 %s %s :Cannot join channel (+z)", user->nick, cname);
  96                                 return 1;
  97                         }
  98                 }
  99
 100                 return 0;
 101         }
 102
 103         virtual ~ModuleSSLModes()
 104         {
 105                 DELETE(sslm);
 106         }
 107
 108         virtual Version GetVersion()
 109         {
 110                 return Version(1, 0, 0, 0, VF_STATIC | VF_VENDOR);
 111         }
 112 };
 113
 114
 115 class ModuleSSLModesFactory : public ModuleFactory
 116 {
 117  public:
 118         ModuleSSLModesFactory()
 119         {
 120         }
 121
 122         ~ModuleSSLModesFactory()
 123         {
 124         }
 125
 126         virtual Module* CreateModule(Server* Me)
 127         {
 128                 return new ModuleSSLModes(Me);
 129         }
 130
 131 };
 132
 133
 134 extern "C" void * init_module( void )
 135 {
 136         return new ModuleSSLModesFactory;
 137 }