include/builtinmodes.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
   5  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   6  *   Copyright (C) 2006 Craig Edwards <craigedwards@brainbox.cc>
   7  *
   8  * This file is part of InspIRCd.  InspIRCd is free software: you can
   9  * redistribute it and/or modify it under the terms of the GNU General Public
  10  * License as published by the Free Software Foundation, version 2.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #pragma once
  22
  23 #include "mode.h"
  24 #include "channels.h"
  25 #include "listmode.h"
  26
  27 /** Channel mode +b
  28  */
  29 class ModeChannelBan : public ListModeBase
  30 {
  31  public:
  32         ModeChannelBan()
  33                 : ListModeBase(NULL, "ban", 'b', "End of channel ban list", 367, 368, true, "maxbans")
  34         {
  35         }
  36 };
  37
  38 /** Channel mode +i
  39  */
  40 class ModeChannelInviteOnly : public SimpleChannelModeHandler
  41 {
  42  public:
  43         ModeChannelInviteOnly() : SimpleChannelModeHandler(NULL, "inviteonly", 'i')
  44         {
  45         }
  46 };
  47
  48 /** Channel mode +k
  49  */
  50 class ModeChannelKey : public ParamMode<ModeChannelKey, LocalStringExt>
  51 {
  52  public:
  53         ModeChannelKey();
  54         ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
  55         void SerializeParam(Channel* chan, const std::string* key, std::string& out);
  56         ModeAction OnSet(User* source, Channel* chan, std::string& param);
  57 };
  58
  59 /** Channel mode +l
  60  */
  61 class ModeChannelLimit : public ParamMode<ModeChannelLimit, LocalIntExt>
  62 {
  63  public:
  64         ModeChannelLimit();
  65         bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel* channel);
  66         void SerializeParam(Channel* chan, intptr_t n, std::string& out);
  67         ModeAction OnSet(User* source, Channel* channel, std::string& parameter);
  68 };
  69
  70 /** Channel mode +m
  71  */
  72 class ModeChannelModerated : public SimpleChannelModeHandler
  73 {
  74  public:
  75         ModeChannelModerated() : SimpleChannelModeHandler(NULL, "moderated", 'm')
  76         {
  77         }
  78 };
  79
  80 /** Channel mode +n
  81  */
  82 class ModeChannelNoExternal : public SimpleChannelModeHandler
  83 {
  84  public:
  85         ModeChannelNoExternal() : SimpleChannelModeHandler(NULL, "noextmsg", 'n')
  86         {
  87         }
  88 };
  89
  90 /** Channel mode +o
  91  */
  92 class ModeChannelOp : public PrefixMode
  93 {
  94  public:
  95         ModeChannelOp();
  96 };
  97
  98 /** Channel mode +p
  99  */
 100 class ModeChannelPrivate : public SimpleChannelModeHandler
 101 {
 102  public:
 103         ModeChannelPrivate() : SimpleChannelModeHandler(NULL, "private", 'p')
 104         {
 105         }
 106 };
 107
 108 /** Channel mode +s
 109  */
 110 class ModeChannelSecret : public SimpleChannelModeHandler
 111 {
 112  public:
 113         ModeChannelSecret() : SimpleChannelModeHandler(NULL, "secret", 's')
 114         {
 115         }
 116 };
 117
 118 /** Channel mode +t
 119  */
 120 class ModeChannelTopicOps : public SimpleChannelModeHandler
 121 {
 122  public:
 123         ModeChannelTopicOps() : SimpleChannelModeHandler(NULL, "topiclock", 't')
 124         {
 125         }
 126 };
 127
 128 /** Channel mode +v
 129  */
 130 class ModeChannelVoice : public PrefixMode
 131 {
 132  public:
 133         ModeChannelVoice();
 134 };
 135
 136 /** User mode +i
 137  */
 138 class ModeUserInvisible : public SimpleUserModeHandler
 139 {
 140  public:
 141         ModeUserInvisible() : SimpleUserModeHandler(NULL, "invisible", 'i')
 142         {
 143         }
 144 };
 145
 146 /** User mode +s
 147  */
 148 class ModeUserServerNoticeMask : public ModeHandler
 149 {
 150         /** Process a snomask modifier string, e.g. +abc-de
 151          * @param user The target user
 152          * @param input A sequence of notice mask characters
 153          * @return The cleaned mode sequence which can be output,
 154          * e.g. in the above example if masks c and e are not
 155          * valid, this function will return +ab-d
 156          */
 157         std::string ProcessNoticeMasks(User* user, const std::string& input);
 158
 159  public:
 160         ModeUserServerNoticeMask();
 161         ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
 162         void OnParameterMissing(User* user, User* dest, Channel* channel);
 163
 164         /** Create a displayable mode string of the snomasks set on a given user
 165          * @param user The user whose notice masks to format
 166          * @return The notice mask character sequence
 167          */
 168         std::string GetUserParameter(User* user);
 169 };
 170
 171 /** User mode +o
 172  */
 173 class ModeUserOperator : public ModeHandler
 174 {
 175  public:
 176         ModeUserOperator();
 177         ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
 178 };