include/mode.h

   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 #ifndef __MODE_H
  18 #define __MODE_H
  19
  20 // include the common header files
  21
  22 #include <typeinfo>
  23 #include <iostream>
  24 #include <string>
  25 #include <deque>
  26 #include <sstream>
  27 #include <vector>
  28 #include "users.h"
  29 #include "channels.h"
  30 #include "ctables.h"
  31
  32 /**
  33  * This enum contains a set of bitmasks which
  34  * are used to compress the 'standard' usermodes
  35  * +isw into a bitfield for fast checking.
  36  */
  37 enum UserModeBits {
  38         UM_INVISIBLE = 1,
  39         UM_SERVERNOTICE = 2,
  40         UM_WALLOPS = 4
  41 };
  42
  43 /**
  44  * Holds the values for different type of modes
  45  * that can exist, USER or CHANNEL type.
  46  */
  47 enum ModeType {
  48         MODETYPE_USER = 0,
  49         MODETYPE_CHANNEL = 1
  50 };
  51
  52 /**
  53  * Holds mode actions - modes can be allowed or denied.
  54  */
  55 enum ModeAction {
  56         MODEACTION_DENY = 0, /* Drop the mode change, AND a parameter if its a parameterized mode */
  57         MODEACTION_ALLOW = 1 /* Allow the mode */
  58 };
  59
  60 /**
  61  * Used to mask off the mode types in the mode handler
  62  * array. Used in a simple two instruction hashing function
  63  * "(modeletter - 65) OR mask"
  64  */
  65 enum ModeMasks {
  66         MASK_USER = 128,        /* A user mode */
  67         MASK_CHANNEL = 0        /* A channel mode */
  68 };
  69
  70 /** Each mode is implemented by ONE ModeHandler class.
  71  * You must derive ModeHandler and add the child class to
  72  * the list of modes handled by the ircd, using
  73  * ModeParser::AddMode. When the mode you implement is
  74  * set by a user, the virtual function OnModeChange is
  75  * called. If you specify a value greater than 0 for
  76  * parameters_on or parameters_off, then when the mode is
  77  * set or unset respectively, std::string &parameter will
  78  * contain the parameter given by the user, else it will
  79  * contain an empty string. You may alter this parameter
  80  * string, and if you alter it to an empty string, and your
  81  * mode is expected to have a parameter, then this is
  82  * equivalent to returning MODEACTION_DENY.
  83  */
  84 class ModeHandler
  85 {
  86         /**
  87          * The mode letter you're implementing.
  88          */
  89         char mode;
  90         /**
  91          * Number of parameters when being set
  92          */
  93         int n_params_on;
  94         /**
  95          * Number of parameters when being unset
  96          */
  97         int n_params_off;
  98         /**
  99          * Mode is a 'list' mode. The behaviour
 100          * of your mode is now set entirely within
 101          * the class as of the 1.1 api, rather than
 102          * inside the mode parser as in the 1.0 api,
 103          * so the only use of this value (along with
 104          * IsListMode()) is for the core to determine
 105          * wether your module can produce 'lists' or not
 106          * (e.g. banlists, etc)
 107          */
 108         bool list;
 109         /**
 110          * The mode type, either MODETYPE_USER or
 111          * MODETYPE_CHANNEL.
 112          */
 113         ModeType m_type;
 114         /**
 115          * True if the mode requires oper status
 116          * to set.
 117          */
 118         bool oper;
 119
 120  public:
 121         ModeHandler(char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly);
 122         virtual ~ModeHandler();
 123
 124         bool IsListMode();
 125         ModeType GetModeType();
 126         bool NeedsOper();
 127         int GetNumParams(bool adding);
 128         char GetModeChar();
 129
 130         virtual ModeAction OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding); /* Can change the mode parameter as its a ref */
 131         virtual void DisplayList(userrec* user, chanrec* channel);
 132         virtual bool CheckTimeStamp(time_t theirs, time_t ours, const std::string &their_param, const std::string &our_param, chanrec* channel);
 133 };
 134
 135 class ModeWatcher
 136 {
 137         char mode;
 138         ModeType m_type;
 139
 140  public:
 141         ModeWatcher(char modeletter, ModeType type);
 142         virtual ~ModeWatcher();
 143
 144         char GetModeChar();
 145         ModeType GetModeType();
 146
 147         virtual bool BeforeMode(userrec* source, userrec* dest, chanrec* channel, std::string &parameter, bool adding, ModeType type); /* Can change the mode parameter */
 148         virtual void AfterMode(userrec* source, userrec* dest, chanrec* channel, const std::string &parameter, bool adding, ModeType type);
 149 };
 150
 151 typedef std::vector<ModeWatcher*>::iterator ModeWatchIter;
 152
 153 class ModeParser
 154 {
 155  private:
 156         /**
 157          * Mode handlers for each mode, to access a handler subtract
 158          * 65 from the ascii value of the mode letter.
 159          * The upper bit of the value indicates if its a usermode
 160          * or a channel mode, so we have 256 of them not 64.
 161          */
 162         ModeHandler* modehandlers[256];
 163         /**
 164          * Mode watcher classes arranged in the same way as the
 165          * mode handlers, except for instead of having 256 of them
 166          * we have 256 lists of them.
 167          */
 168         std::vector<ModeWatcher*> modewatchers[256];
 169
 170         char* GiveOps(userrec *user,char *dest,chanrec *chan,int status);
 171         char* GiveHops(userrec *user,char *dest,chanrec *chan,int status);
 172         char* GiveVoice(userrec *user,char *dest,chanrec *chan,int status);
 173         char* TakeOps(userrec *user,char *dest,chanrec *chan,int status);
 174         char* TakeHops(userrec *user,char *dest,chanrec *chan,int status);
 175         char* TakeVoice(userrec *user,char *dest,chanrec *chan,int status);
 176         userrec* SanityChecks(userrec *user,char *dest,chanrec *chan,int status);
 177         char* Grant(userrec *d,chanrec *chan,int MASK);
 178         char* Revoke(userrec *d,chanrec *chan,int MASK);
 179  public:
 180         ModeParser();
 181         bool AddMode(ModeHandler* mh, unsigned const char modeletter);
 182         void Process(char **parameters, int pcnt, userrec *user, bool servermode);
 183
 184         //void ServerMode(char **parameters, int pcnt, userrec *user);
 185 };
 186
 187 class cmd_mode : public command_t
 188 {
 189  public:
 190         cmd_mode () : command_t("MODE",0,1) { }
 191         void Handle(char **parameters, int pcnt, userrec *user);
 192 };
 193
 194 #endif