include/channels.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
   6  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   7  *   Copyright (C) 2003-2007 Craig Edwards <craigedwards@brainbox.cc>
   8  *
   9  * This file is part of InspIRCd.  InspIRCd is free software: you can
  10  * redistribute it and/or modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation, version 2.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 #pragma once
  24
  25 #include "membership.h"
  26 #include "mode.h"
  27
  28 /** Holds an entry for a ban list, exemption list, or invite list.
  29  * This class contains a single element in a channel list, such as a banlist.
  30  */
  31
  32 /** Holds all relevent information for a channel.
  33  * This class represents a channel, and contains its name, modes, topic, topic set time,
  34  * etc, and an instance of the BanList type.
  35  */
  36 class CoreExport Channel : public Extensible, public InviteBase
  37 {
  38         /** Set default modes for the channel on creation
  39          */
  40         void SetDefaultModes();
  41
  42         /** Modes for the channel.
  43          * This is not a null terminated string! It is a bitset where
  44          * each item in it represents if a mode is set. For example
  45          * for mode +A, index 0. Use modechar-65 to calculate which
  46          * field to check.
  47          */
  48         std::bitset<64> modes;
  49
  50         /** Parameters for custom modes.
  51          * One for each custom mode letter.
  52          */
  53         CustomModeList custom_mode_params;
  54
  55         /** Remove the given membership from the channel's internal map of
  56          * memberships and destroy the Membership object.
  57          * This function does not remove the channel from User::chanlist.
  58          * Since the parameter is an iterator to the target, the complexity
  59          * of this function is constant.
  60          * @param membiter The UserMembIter to remove, must be valid
  61          */
  62         void DelUser(const UserMembIter& membiter);
  63
  64  public:
  65         /** Creates a channel record and initialises it with default values
  66          * @param name The name of the channel
  67          * @param ts The creation time of the channel
  68          * @throw CoreException if this channel name is in use
  69          */
  70         Channel(const std::string &name, time_t ts);
  71
  72         /** Checks whether the channel should be destroyed, and if yes, begins
  73          * the teardown procedure.
  74          *
  75          * If there are users on the channel or a module vetoes the deletion
  76          * (OnPreChannelDelete hook) then nothing else happens.
  77          * Otherwise, first the OnChannelDelete event is fired, then the channel is
  78          * removed from the channel list. All pending invites are destroyed and
  79          * finally the channel is added to the cull list.
  80          */
  81         void CheckDestroy();
  82
  83         /** The channel's name.
  84          */
  85         std::string name;
  86
  87         /** Time that the object was instantiated (used for TS calculation etc)
  88         */
  89         time_t age;
  90
  91         /** User list.
  92          */
  93         UserMembList userlist;
  94
  95         /** Channel topic.
  96          * If this is an empty string, no channel topic is set.
  97          */
  98         std::string topic;
  99
 100         /** Time topic was set.
 101          * If no topic was ever set, this will be equal to Channel::created
 102          */
 103         time_t topicset;
 104
 105         /** The last user to set the topic.
 106          * If this member is an empty string, no topic was ever set.
 107          */
 108         std::string setby; /* 128 */
 109
 110         /** Sets or unsets a custom mode in the channels info
 111          * @param mode The mode character to set or unset
 112          * @param value True if you want to set the mode or false if you want to remove it
 113          */
 114         void SetMode(ModeHandler* mode, bool value);
 115
 116         /** Sets or unsets a custom mode in the channels info
 117          * @param mode The mode character to set or unset
 118          * @param parameter The parameter string to associate with this mode character.
 119          * If it is empty, the mode is unset; if it is nonempty, the mode is set.
 120          */
 121         void SetModeParam(ModeHandler* mode, const std::string& parameter);
 122
 123         /** Returns true if a mode is set on a channel
 124           * @param mode The mode character you wish to query
 125           * @return True if the custom mode is set, false if otherwise
 126           */
 127         inline bool IsModeSet(ModeHandler* mode) { return modes[mode->GetModeChar()-'A']; }
 128         bool IsModeSet(ModeHandler& mode) { return IsModeSet(&mode); }
 129         bool IsModeSet(ChanModeReference& mode);
 130
 131         /** Returns the parameter for a custom mode on a channel.
 132           * @param mode The mode character you wish to query
 133           *
 134           * For example if "+L #foo" is set, and you pass this method
 135           * 'L', it will return '\#foo'. If the mode is not set on the
 136           * channel, or the mode has no parameters associated with it,
 137           * it will return an empty string.
 138           *
 139           * @return The parameter for this mode is returned, or an empty string
 140           */
 141         std::string GetModeParameter(ModeHandler* mode);
 142         std::string GetModeParameter(ChanModeReference& mode);
 143
 144         /** Sets the channel topic.
 145          * @param user The user setting the topic.
 146          * @param topic The topic to set it to.
 147          */
 148         void SetTopic(User* user, const std::string& topic);
 149
 150         /** Obtain the channel "user counter"
 151          * This returns the number of users on this channel
 152          *
 153          * @return The number of users on this channel
 154          */
 155         long GetUserCounter() const { return userlist.size(); }
 156
 157         /** Add a user pointer to the internal reference list
 158          * @param user The user to add
 159          *
 160          * The data inserted into the reference list is a table as it is
 161          * an arbitary pointer compared to other users by its memory address,
 162          * as this is a very fast 32 or 64 bit integer comparison.
 163          */
 164         Membership* AddUser(User* user);
 165
 166         /** Delete a user pointer to the internal reference list
 167          * @param user The user to delete
 168          * @return number of users left on the channel after deletion of the user
 169          */
 170         void DelUser(User* user);
 171
 172         /** Obtain the internal reference list
 173          * The internal reference list contains a list of User*.
 174          * These are used for rapid comparison to determine
 175          * channel membership for PRIVMSG, NOTICE, QUIT, PART etc.
 176          * The resulting pointer to the vector should be considered
 177          * readonly and only modified via AddUser and DelUser.
 178          *
 179          * @return This function returns pointer to a map of User pointers (CUList*).
 180          */
 181         const UserMembList* GetUsers() const { return &userlist; }
 182
 183         /** Returns true if the user given is on the given channel.
 184          * @param user The user to look for
 185          * @return True if the user is on this channel
 186          */
 187         bool HasUser(User* user);
 188
 189         Membership* GetUser(User* user);
 190
 191         /** Make src kick user from this channel with the given reason.
 192          * @param src The source of the kick
 193          * @param user The user being kicked (must be on this channel)
 194          * @param reason The reason for the kick
 195          * @param srcmemb The membership of the user who does the kick, can be NULL
 196          */
 197         void KickUser(User* src, User* user, const std::string& reason, Membership* srcmemb = NULL);
 198
 199         /** Part a user from this channel with the given reason.
 200          * If the reason field is NULL, no reason will be sent.
 201          * @param user The user who is parting (must be on this channel)
 202          * @param reason The part reason
 203          */
 204         void PartUser(User *user, std::string &reason);
 205
 206         /** Join a local user to a channel, with or without permission checks. May be a channel that doesn't exist yet.
 207          * @param user The user to join to the channel.
 208          * @param channame The channel name to join to. Does not have to exist.
 209          * @param key The key of the channel, if given
 210          * @param override If true, override all join restrictions such as +bkil
 211          * @return A pointer to the Channel the user was joined to. A new Channel may have
 212          * been created if the channel did not exist before the user was joined to it.
 213          * If the user could not be joined to a channel, the return value is NULL.
 214          */
 215         static Channel* JoinUser(LocalUser* user, std::string channame, bool override = false, const std::string& key = "");
 216
 217         /** Join a user to an existing channel, without doing any permission checks
 218          * @param user The user to join to the channel
 219          * @param privs Priviliges (prefix mode letters) to give to this user, may be NULL
 220          * @param bursting True if this join is the result of a netburst (passed to modules in the OnUserJoin hook)
 221          * @param created_by_local True if this channel was just created by a local user (passed to modules in the OnUserJoin hook)
 222          */
 223         void ForceJoin(User* user, const std::string* privs = NULL, bool bursting = false, bool created_by_local = false);
 224
 225         /** Write to a channel, from a user, using va_args for text
 226          * @param user User whos details to prefix the line with
 227          * @param text A printf-style format string which builds the output line without prefix
 228          * @param ... Zero or more POD types
 229          */
 230         void WriteChannel(User* user, const char* text, ...) CUSTOM_PRINTF(3, 4);
 231
 232         /** Write to a channel, from a user, using std::string for text
 233          * @param user User whos details to prefix the line with
 234          * @param text A std::string containing the output line without prefix
 235          */
 236         void WriteChannel(User* user, const std::string &text);
 237
 238         /** Write to a channel, from a server, using va_args for text
 239          * @param ServName Server name to prefix the line with
 240          * @param text A printf-style format string which builds the output line without prefix
 241          * @param ... Zero or more POD type
 242          */
 243         void WriteChannelWithServ(const std::string& ServName, const char* text, ...) CUSTOM_PRINTF(3, 4);
 244
 245         /** Write to a channel, from a server, using std::string for text
 246          * @param ServName Server name to prefix the line with
 247          * @param text A std::string containing the output line without prefix
 248          */
 249         void WriteChannelWithServ(const std::string& ServName, const std::string &text);
 250
 251         /** Write to all users on a channel except a specific user, using va_args for text.
 252          * Internally, this calls WriteAllExcept().
 253          * @param user User whos details to prefix the line with, and to omit from receipt of the message
 254          * @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
 255          * use the nick!user\@host of the user.
 256          * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
 257          * @param text A printf-style format string which builds the output line without prefix
 258          * @param ... Zero or more POD type
 259          */
 260         void WriteAllExceptSender(User* user, bool serversource, char status, const char* text, ...) CUSTOM_PRINTF(5, 6);
 261
 262         /** Write to all users on a channel except a list of users, using va_args for text
 263          * @param user User whos details to prefix the line with, and to omit from receipt of the message
 264          * @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
 265          * use the nick!user\@host of the user.
 266          * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
 267          * @param except_list A list of users NOT to send the text to
 268          * @param text A printf-style format string which builds the output line without prefix
 269          * @param ... Zero or more POD type
 270          */
 271         void WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const char* text, ...) CUSTOM_PRINTF(6, 7);
 272
 273         /** Write to all users on a channel except a specific user, using std::string for text.
 274          * Internally, this calls WriteAllExcept().
 275          * @param user User whos details to prefix the line with, and to omit from receipt of the message
 276          * @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
 277          * use the nick!user\@host of the user.
 278          * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
 279          * @param text A std::string containing the output line without prefix
 280          */
 281         void WriteAllExceptSender(User* user, bool serversource, char status, const std::string& text);
 282
 283         /** Write to all users on a channel except a list of users, using std::string for text
 284          * @param user User whos details to prefix the line with, and to omit from receipt of the message
 285          * @param serversource If this parameter is true, use the local server name as the source of the text, otherwise,
 286          * use the nick!user\@host of the user.
 287          * @param status The status of the users to write to, e.g. '@' or '%'. Use a value of 0 to write to everyone
 288          * @param except_list A list of users NOT to send the text to
 289          * @param text A std::string containing the output line without prefix
 290          */
 291         void WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const std::string& text);
 292         /** Write a line of text that already includes the source */
 293         void RawWriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const std::string& text);
 294
 295         /** Return the channel's modes with parameters.
 296          * @param showkey If this is set to true, the actual key is shown,
 297          * otherwise it is replaced with '&lt;KEY&gt;'
 298          * @return The channel mode string
 299          */
 300         const char* ChanModes(bool showkey);
 301
 302         /** Spool the NAMES list for this channel to the given user
 303          * @param user The user to spool the NAMES list to
 304          */
 305         void UserList(User *user);
 306
 307         /** Get a users prefix on this channel in a string.
 308          * @param user The user to look up
 309          * @return A character array containing the prefix string.
 310          * Unlike GetStatus and GetStatusFlags which will only return the
 311          * core specified modes @, % and + (op, halfop and voice), GetPrefixChar
 312          * will also return module-defined prefixes. If the user has to prefix,
 313          * an empty but non-null string is returned. If the user has multiple
 314          * prefixes, the highest is returned. If you do not recognise the prefix
 315          * character you can get, you can deal with it in a 'proprtional' manner
 316          * compared to known prefixes, using GetPrefixValue().
 317          */
 318         const char* GetPrefixChar(User *user);
 319
 320         /** Return all of a users mode prefixes into a char* string.
 321          * @param user The user to look up
 322          * @return A list of all prefix characters. The prefixes will always
 323          * be in rank order, greatest first, as certain IRC clients require
 324          * this when multiple prefixes are used names lists.
 325          */
 326         const char* GetAllPrefixChars(User* user);
 327
 328         /** Get the value of a users prefix on this channel.
 329          * @param user The user to look up
 330          * @return The module or core-defined value of the users prefix.
 331          * The values for op, halfop and voice status are constants in
 332          * mode.h, and are OP_VALUE, HALFOP_VALUE, and VOICE_VALUE respectively.
 333          * If the value you are given does not match one of these three, it is
 334          * a module-defined mode, and it should be compared in proportion to
 335          * these three constants. For example a value greater than OP_VALUE
 336          * is a prefix of greater 'worth' than ops, and a value less than
 337          * VOICE_VALUE is of lesser 'worth' than a voice.
 338          */
 339         unsigned int GetPrefixValue(User* user);
 340
 341         /** Add a prefix character to a user.
 342          * Only the core should call this method, usually  from
 343          * within the mode parser or when the first user joins
 344          * the channel (to grant ops to them)
 345          * @param user The user to associate the privilage with
 346          * @param prefix The prefix character to associate
 347          * @param adding True if adding the prefix, false when removing
 348          * @return True if a change was made
 349          */
 350         bool SetPrefix(User* user, char prefix, bool adding);
 351
 352         /** Check if a user is banned on this channel
 353          * @param user A user to check against the banlist
 354          * @returns True if the user given is banned
 355          */
 356         bool IsBanned(User* user);
 357
 358         /** Check a single ban for match
 359          */
 360         bool CheckBan(User* user, const std::string& banmask);
 361
 362         /** Get the status of an "action" type extban
 363          */
 364         ModResult GetExtBanStatus(User *u, char type);
 365 };
 366
 367 inline bool Channel::HasUser(User* user)
 368 {
 369         return (userlist.find(user) != userlist.end());
 370 }
 371
 372 inline std::string Channel::GetModeParameter(ChanModeReference& mode)
 373 {
 374         if (!mode)
 375                 return "";
 376         return GetModeParameter(*mode);
 377 }
 378
 379 inline bool Channel::IsModeSet(ChanModeReference& mode)
 380 {
 381         if (!mode)
 382                 return false;
 383         return IsModeSet(*mode);
 384 }