include/users.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
   6  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
   7  *   Copyright (C) 2003-2007 Craig Edwards <craigedwards@brainbox.cc>
   8  *   Copyright (C) 2007 Burlex <???@???>
   9  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
  10  *
  11  * This file is part of InspIRCd.  InspIRCd is free software: you can
  12  * redistribute it and/or modify it under the terms of the GNU General Public
  13  * License as published by the Free Software Foundation, version 2.
  14  *
  15  * This program is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24
  25 #pragma once
  26
  27 #include "socket.h"
  28 #include "inspsocket.h"
  29 #include "mode.h"
  30 #include "membership.h"
  31
  32 /** connect class types
  33  */
  34 enum ClassTypes {
  35         /** connect:allow */
  36         CC_ALLOW = 0,
  37         /** connect:deny */
  38         CC_DENY  = 1,
  39         /** named connect block (for opers, etc) */
  40         CC_NAMED = 2
  41 };
  42
  43 /** Registration state of a user, e.g.
  44  * have they sent USER, NICK, PASS yet?
  45  */
  46 enum RegistrationState {
  47
  48 #ifndef _WIN32   // Burlex: This is already defined in win32, luckily it is still 0.
  49         REG_NONE = 0,           /* Has sent nothing */
  50 #endif
  51
  52         REG_USER = 1,           /* Has sent USER */
  53         REG_NICK = 2,           /* Has sent NICK */
  54         REG_NICKUSER = 3,       /* Bitwise combination of REG_NICK and REG_USER */
  55         REG_ALL = 7             /* REG_NICKUSER plus next bit along */
  56 };
  57
  58 enum UserType {
  59         USERTYPE_LOCAL = 1,
  60         USERTYPE_REMOTE = 2,
  61         USERTYPE_SERVER = 3
  62 };
  63
  64 /** Holds information relevent to &lt;connect allow&gt; and &lt;connect deny&gt; tags in the config file.
  65  */
  66 struct CoreExport ConnectClass : public refcountbase
  67 {
  68         reference<ConfigTag> config;
  69         /** Type of line, either CC_ALLOW or CC_DENY
  70          */
  71         char type;
  72
  73         /** True if this class uses fake lag to manage flood, false if it kills */
  74         bool fakelag;
  75
  76         /** Connect class name
  77          */
  78         std::string name;
  79
  80         /** Max time to register the connection in seconds
  81          */
  82         unsigned int registration_timeout;
  83
  84         /** Host mask for this line
  85          */
  86         std::string host;
  87
  88         /** Number of seconds between pings for this line
  89          */
  90         unsigned int pingtime;
  91
  92         /** Maximum size of sendq for users in this class (bytes)
  93          * Users cannot send commands if they go over this limit
  94          */
  95         unsigned long softsendqmax;
  96
  97         /** Maximum size of sendq for users in this class (bytes)
  98          * Users are killed if they go over this limit
  99          */
 100         unsigned long hardsendqmax;
 101
 102         /** Maximum size of recvq for users in this class (bytes)
 103          */
 104         unsigned long recvqmax;
 105
 106         /** Seconds worth of penalty before penalty system activates
 107          */
 108         unsigned int penaltythreshold;
 109
 110         /** Maximum rate of commands (units: millicommands per second) */
 111         unsigned int commandrate;
 112
 113         /** Local max when connecting by this connection class
 114          */
 115         unsigned long maxlocal;
 116
 117         /** Global max when connecting by this connection class
 118          */
 119         unsigned long maxglobal;
 120
 121         /** True if max connections for this class is hit and a warning is wanted
 122          */
 123         bool maxconnwarn;
 124
 125         /** Max channels for this class
 126          */
 127         unsigned int maxchans;
 128
 129         /** How many users may be in this connect class before they are refused?
 130          * (0 = no limit = default)
 131          */
 132         unsigned long limit;
 133
 134         /** If set to true, no user DNS lookups are to be performed
 135          */
 136         bool resolvehostnames;
 137
 138         /** Create a new connect class with no settings.
 139          */
 140         ConnectClass(ConfigTag* tag, char type, const std::string& mask);
 141         /** Create a new connect class with inherited settings.
 142          */
 143         ConnectClass(ConfigTag* tag, char type, const std::string& mask, const ConnectClass& parent);
 144
 145         /** Update the settings in this block to match the given block */
 146         void Update(const ConnectClass* newSettings);
 147
 148         const std::string& GetName() { return name; }
 149         const std::string& GetHost() { return host; }
 150
 151         /** Returns the registration timeout
 152          */
 153         time_t GetRegTimeout()
 154         {
 155                 return (registration_timeout ? registration_timeout : 90);
 156         }
 157
 158         /** Returns the ping frequency
 159          */
 160         unsigned int GetPingTime()
 161         {
 162                 return (pingtime ? pingtime : 120);
 163         }
 164
 165         /** Returns the maximum sendq value (soft limit)
 166          * Note that this is in addition to internal OS buffers
 167          */
 168         unsigned long GetSendqSoftMax()
 169         {
 170                 return (softsendqmax ? softsendqmax : 4096);
 171         }
 172
 173         /** Returns the maximum sendq value (hard limit)
 174          */
 175         unsigned long GetSendqHardMax()
 176         {
 177                 return (hardsendqmax ? hardsendqmax : 0x100000);
 178         }
 179
 180         /** Returns the maximum recvq value
 181          */
 182         unsigned long GetRecvqMax()
 183         {
 184                 return (recvqmax ? recvqmax : 4096);
 185         }
 186
 187         /** Returns the penalty threshold value
 188          */
 189         unsigned int GetPenaltyThreshold()
 190         {
 191                 return penaltythreshold ? penaltythreshold : (fakelag ? 10 : 20);
 192         }
 193
 194         unsigned int GetCommandRate()
 195         {
 196                 return commandrate ? commandrate : 1000;
 197         }
 198
 199         /** Return the maximum number of local sessions
 200          */
 201         unsigned long GetMaxLocal()
 202         {
 203                 return maxlocal;
 204         }
 205
 206         /** Returns the maximum number of global sessions
 207          */
 208         unsigned long GetMaxGlobal()
 209         {
 210                 return maxglobal;
 211         }
 212 };
 213
 214 /** Holds all information about a user
 215  * This class stores all information about a user connected to the irc server. Everything about a
 216  * connection is stored here primarily, from the user's socket ID (file descriptor) through to the
 217  * user's nickname and hostname.
 218  */
 219 class CoreExport User : public Extensible
 220 {
 221  private:
 222         /** Cached nick!ident@dhost value using the displayed hostname
 223          */
 224         std::string cached_fullhost;
 225
 226         /** Cached ident@ip value using the real IP address
 227          */
 228         std::string cached_hostip;
 229
 230         /** Cached ident@realhost value using the real hostname
 231          */
 232         std::string cached_makehost;
 233
 234         /** Cached nick!ident@realhost value using the real hostname
 235          */
 236         std::string cached_fullrealhost;
 237
 238         /** Set by GetIPString() to avoid constantly re-grabbing IP via sockets voodoo.
 239          */
 240         std::string cachedip;
 241
 242         /** The user's mode list.
 243          * Much love to the STL for giving us an easy to use bitset, saving us RAM.
 244          * if (modes[modeid]) is set, then the mode is set.
 245          * For example, to work out if mode +i is set, we check the field
 246          * User::modes[invisiblemode->modeid] == true.
 247          */
 248         std::bitset<ModeParser::MODEID_MAX> modes;
 249
 250  public:
 251
 252         /** Hostname of connection.
 253          * This should be valid as per RFC1035.
 254          */
 255         std::string host;
 256
 257         /** Time that the object was instantiated (used for TS calculation etc)
 258         */
 259         time_t age;
 260
 261         /** Time the connection was created, set in the constructor. This
 262          * may be different from the time the user's classbase object was
 263          * created.
 264          */
 265         time_t signon;
 266
 267         /** Client address that the user is connected from.
 268          * Do not modify this value directly, use SetClientIP() to change it.
 269          * Port is not valid for remote users.
 270          */
 271         irc::sockets::sockaddrs client_sa;
 272
 273         /** The users nickname.
 274          * An invalid nickname indicates an unregistered connection prior to the NICK command.
 275          * Use InspIRCd::IsNick() to validate nicknames.
 276          */
 277         std::string nick;
 278
 279         /** The user's unique identifier.
 280          * This is the unique identifier which the user has across the network.
 281          */
 282         const std::string uuid;
 283
 284         /** The users ident reply.
 285          * Two characters are added to the user-defined limit to compensate for the tilde etc.
 286          */
 287         std::string ident;
 288
 289         /** The host displayed to non-opers (used for cloaking etc).
 290          * This usually matches the value of User::host.
 291          */
 292         std::string dhost;
 293
 294         /** The users full name (GECOS).
 295          */
 296         std::string fullname;
 297
 298         /** What snomasks are set on this user.
 299          * This functions the same as the above modes.
 300          */
 301         std::bitset<64> snomasks;
 302
 303         /** Channels this user is on
 304          */
 305         UserChanList chans;
 306
 307         /** The server the user is connected to.
 308          */
 309         Server* server;
 310
 311         /** The user's away message.
 312          * If this string is empty, the user is not marked as away.
 313          */
 314         std::string awaymsg;
 315
 316         /** Time the user last went away.
 317          * This is ONLY RELIABLE if user IsAway()!
 318          */
 319         time_t awaytime;
 320
 321         /** The oper type they logged in as, if they are an oper.
 322          */
 323         reference<OperInfo> oper;
 324
 325         /** Used by User to indicate the registration status of the connection
 326          * It is a bitfield of the REG_NICK, REG_USER and REG_ALL bits to indicate
 327          * the connection state.
 328          */
 329         unsigned int registered:3;
 330
 331         /** If this is set to true, then all socket operations for the user
 332          * are dropped into the bit-bucket.
 333          * This value is set by QuitUser, and is not needed seperately from that call.
 334          * Please note that setting this value alone will NOT cause the user to quit.
 335          */
 336         unsigned int quitting:1;
 337
 338         /** What type of user is this? */
 339         const unsigned int usertype:2;
 340
 341         /** Get client IP string from sockaddr, using static internal buffer
 342          * @return The IP string
 343          */
 344         const std::string& GetIPString();
 345
 346         /** Get CIDR mask, using default range, for this user
 347          */
 348         irc::sockets::cidr_mask GetCIDRMask();
 349
 350         /** Sets the client IP for this user
 351          * @return true if the conversion was successful
 352          */
 353         virtual bool SetClientIP(const char* sip, bool recheck_eline = true);
 354
 355         virtual void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
 356
 357         /** Constructor
 358          * @throw CoreException if the UID allocated to the user already exists
 359          */
 360         User(const std::string& uid, Server* srv, int objtype);
 361
 362         /** Returns the full displayed host of the user
 363          * This member function returns the hostname of the user as seen by other users
 364          * on the server, in nick!ident\@host form.
 365          * @return The full masked host of the user
 366          */
 367         virtual const std::string& GetFullHost();
 368
 369         /** Returns the full real host of the user
 370          * This member function returns the hostname of the user as seen by other users
 371          * on the server, in nick!ident\@host form. If any form of hostname cloaking is in operation,
 372          * e.g. through a module, then this method will ignore it and return the true hostname.
 373          * @return The full real host of the user
 374          */
 375         virtual const std::string& GetFullRealHost();
 376
 377         /** This clears any cached results that are used for GetFullRealHost() etc.
 378          * The results of these calls are cached as generating them can be generally expensive.
 379          */
 380         void InvalidateCache();
 381
 382         /** Returns whether this user is currently away or not. If true,
 383          * further information can be found in User::awaymsg and User::awaytime
 384          * @return True if the user is away, false otherwise
 385          */
 386         bool IsAway() const { return (!awaymsg.empty()); }
 387
 388         /** Returns whether this user is an oper or not. If true,
 389          * oper information can be obtained from User::oper
 390          * @return True if the user is an oper, false otherwise
 391          */
 392         bool IsOper() const { return oper; }
 393
 394         /** Returns true if a notice mask is set
 395          * @param sm A notice mask character to check
 396          * @return True if the notice mask is set
 397          */
 398         bool IsNoticeMaskSet(unsigned char sm);
 399
 400         /** Create a displayable mode string for this users umodes
 401          * @param showparameters The mode string
 402          */
 403         const char* FormatModes(bool showparameters = false);
 404
 405         /** Returns true if a specific mode is set
 406          * @param m The user mode
 407          * @return True if the mode is set
 408          */
 409         bool IsModeSet(unsigned char m);
 410         bool IsModeSet(ModeHandler* mh);
 411         bool IsModeSet(ModeHandler& mh) { return IsModeSet(&mh); }
 412         bool IsModeSet(UserModeReference& moderef);
 413
 414         /** Set a specific usermode to on or off
 415          * @param m The user mode
 416          * @param value On or off setting of the mode
 417          */
 418         void SetMode(ModeHandler* mh, bool value);
 419         void SetMode(ModeHandler& mh, bool value) { SetMode(&mh, value); }
 420
 421         /** Returns true or false for if a user can execute a privilaged oper command.
 422          * This is done by looking up their oper type from User::oper, then referencing
 423          * this to their oper classes and checking the commands they can execute.
 424          * @param command A command (should be all CAPS)
 425          * @return True if this user can execute the command
 426          */
 427         virtual bool HasPermission(const std::string &command);
 428
 429         /** Returns true if a user has a given permission.
 430          * This is used to check whether or not users may perform certain actions which admins may not wish to give to
 431          * all operators, yet are not commands. An example might be oper override, mass messaging (/notice $*), etc.
 432          *
 433          * @param privstr The priv to chec, e.g. "users/override/topic". These are loaded free-form from the config file.
 434          * @param noisy If set to true, the user is notified that they do not have the specified permission where applicable. If false, no notification is sent.
 435          * @return True if this user has the permission in question.
 436          */
 437         virtual bool HasPrivPermission(const std::string &privstr, bool noisy = false);
 438
 439         /** Returns true or false if a user can set a privileged user or channel mode.
 440          * This is done by looking up their oper type from User::oper, then referencing
 441          * this to their oper classes, and checking the modes they can set.
 442          * @param mode The mode the check
 443          * @param type ModeType (MODETYPE_CHANNEL or MODETYPE_USER).
 444          * @return True if the user can set or unset this mode.
 445          */
 446         virtual bool HasModePermission(unsigned char mode, ModeType type);
 447
 448         /** Creates a usermask with real host.
 449          * Takes a buffer to use and fills the given buffer with the hostmask in the format user\@host
 450          * @return the usermask in the format user\@host
 451          */
 452         const std::string& MakeHost();
 453
 454         /** Creates a usermask with real ip.
 455          * Takes a buffer to use and fills the given buffer with the ipmask in the format user\@ip
 456          * @return the usermask in the format user\@ip
 457          */
 458         const std::string& MakeHostIP();
 459
 460         /** Oper up the user using the given opertype.
 461          * This will also give the +o usermode.
 462          */
 463         void Oper(OperInfo* info);
 464
 465         /** Oper down.
 466          * This will clear the +o usermode and unset the user's oper type
 467          */
 468         void UnOper();
 469
 470         /** Write text to this user, appending CR/LF. Works on local users only.
 471          * @param text A std::string to send to the user
 472          */
 473         virtual void Write(const std::string &text);
 474
 475         /** Write text to this user, appending CR/LF.
 476          * Works on local users only.
 477          * @param text The format string for text to send to the user
 478          * @param ... POD-type format arguments
 479          */
 480         virtual void Write(const char *text, ...) CUSTOM_PRINTF(2, 3);
 481
 482         /** Write text to this user, appending CR/LF and prepending :server.name
 483          * Works on local users only.
 484          * @param text A std::string to send to the user
 485          */
 486         void WriteServ(const std::string& text);
 487
 488         /** Write text to this user, appending CR/LF and prepending :server.name
 489          * Works on local users only.
 490          * @param text The format string for text to send to the user
 491          * @param ... POD-type format arguments
 492          */
 493         void WriteServ(const char* text, ...) CUSTOM_PRINTF(2, 3);
 494
 495         /** Sends a command to this user.
 496          * @param command The command to be sent.
 497          * @param text The message to send.
 498          */
 499         void WriteCommand(const char* command, const std::string& text);
 500
 501         /** Sends a server notice to this user.
 502          * @param text The contents of the message to send.
 503          */
 504         void WriteNotice(const std::string& text) { this->WriteCommand("NOTICE", ":" + text); }
 505
 506         void WriteNumeric(unsigned int numeric, const char* text, ...) CUSTOM_PRINTF(3, 4);
 507
 508         void WriteNumeric(unsigned int numeric, const std::string &text);
 509
 510         /** Write text to this user, appending CR/LF and prepending :nick!user\@host of the user provided in the first parameter.
 511          * @param user The user to prepend the :nick!user\@host of
 512          * @param text A std::string to send to the user
 513          */
 514         void WriteFrom(User *user, const std::string &text);
 515
 516         /** Write text to this user, appending CR/LF and prepending :nick!user\@host of the user provided in the first parameter.
 517          * @param user The user to prepend the :nick!user\@host of
 518          * @param text The format string for text to send to the user
 519          * @param ... POD-type format arguments
 520          */
 521         void WriteFrom(User *user, const char* text, ...) CUSTOM_PRINTF(3, 4);
 522
 523         /** Write to all users that can see this user (including this user in the list if include_self is true), appending CR/LF
 524          * @param line A std::string to send to the users
 525          * @param include_self Should the message be sent back to the author?
 526          */
 527         void WriteCommonRaw(const std::string &line, bool include_self = true);
 528
 529         /** Write to all users that can see this user (including this user in the list), appending CR/LF
 530          * @param text The format string for text to send to the users
 531          * @param ... POD-type format arguments
 532          */
 533         void WriteCommon(const char* text, ...) CUSTOM_PRINTF(2, 3);
 534
 535         /** Write a quit message to all common users, as in User::WriteCommonExcept but with a specific
 536          * quit message for opers only.
 537          * @param normal_text Normal user quit message
 538          * @param oper_text Oper only quit message
 539          */
 540         void WriteCommonQuit(const std::string &normal_text, const std::string &oper_text);
 541
 542         /** Dump text to a user target, splitting it appropriately to fit
 543          * @param linePrefix text to prefix each complete line with
 544          * @param textStream the text to send to the user
 545          */
 546         void SendText(const std::string& linePrefix, std::stringstream& textStream);
 547
 548         /** Write to the user, routing the line if the user is remote.
 549          */
 550         virtual void SendText(const std::string& line) = 0;
 551
 552         /** Write to the user, routing the line if the user is remote.
 553          */
 554         void SendText(const char* text, ...) CUSTOM_PRINTF(2, 3);
 555
 556         /** Return true if the user shares at least one channel with another user
 557          * @param other The other user to compare the channel list against
 558          * @return True if the given user shares at least one channel with this user
 559          */
 560         bool SharesChannelWith(User *other);
 561
 562         /** Change the displayed host of a user.
 563          * ALWAYS use this function, rather than writing User::dhost directly,
 564          * as this triggers module events allowing the change to be syncronized to
 565          * remote servers.
 566          * @param host The new hostname to set
 567          * @return True if the change succeeded, false if it didn't
 568          * (a module vetoed the change).
 569          */
 570         bool ChangeDisplayedHost(const std::string& host);
 571
 572         /** Change the ident (username) of a user.
 573          * ALWAYS use this function, rather than writing User::ident directly,
 574          * as this triggers module events allowing the change to be syncronized to
 575          * remote servers.
 576          * @param newident The new ident to set
 577          * @return True if the change succeeded, false if it didn't
 578          */
 579         bool ChangeIdent(const std::string& newident);
 580
 581         /** Change a users realname field.
 582          * ALWAYS use this function, rather than writing User::fullname directly,
 583          * as this triggers module events allowing the change to be syncronized to
 584          * remote servers.
 585          * @param gecos The user's new realname
 586          * @return True if the change succeeded, false if otherwise
 587          */
 588         bool ChangeName(const std::string& gecos);
 589
 590         /** Change a user's nick
 591          * @param newnick The new nick
 592          * @return True if the change succeeded
 593          */
 594         bool ChangeNick(const std::string& newnick, time_t newts = 0);
 595
 596         /** Remove this user from all channels they are on, and delete any that are now empty.
 597          * This is used by QUIT, and will not send part messages!
 598          */
 599         void PurgeEmptyChannels();
 600
 601         /** Default destructor
 602          */
 603         virtual ~User();
 604         virtual CullResult cull();
 605 };
 606
 607 class CoreExport UserIOHandler : public StreamSocket
 608 {
 609  public:
 610         LocalUser* const user;
 611         UserIOHandler(LocalUser* me) : user(me) {}
 612         void OnDataReady();
 613         void OnError(BufferedSocketError error);
 614
 615         /** Adds to the user's write buffer.
 616          * You may add any amount of text up to this users sendq value, if you exceed the
 617          * sendq value, the user will be removed, and further buffer adds will be dropped.
 618          * @param data The data to add to the write buffer
 619          */
 620         void AddWriteBuf(const std::string &data);
 621 };
 622
 623 typedef unsigned int already_sent_t;
 624
 625 class CoreExport LocalUser : public User, public InviteBase<LocalUser>, public intrusive_list_node<LocalUser>
 626 {
 627  public:
 628         LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
 629         CullResult cull();
 630
 631         UserIOHandler eh;
 632
 633         /** Stats counter for bytes inbound
 634          */
 635         unsigned int bytes_in;
 636
 637         /** Stats counter for bytes outbound
 638          */
 639         unsigned int bytes_out;
 640
 641         /** Stats counter for commands inbound
 642          */
 643         unsigned int cmds_in;
 644
 645         /** Stats counter for commands outbound
 646          */
 647         unsigned int cmds_out;
 648
 649         /** Password specified by the user when they registered (if any).
 650          * This is stored even if the \<connect> block doesnt need a password, so that
 651          * modules may check it.
 652          */
 653         std::string password;
 654
 655         /** Contains a pointer to the connect class a user is on from
 656          */
 657         reference<ConnectClass> MyClass;
 658
 659         /** Get the connect class which this user belongs to.
 660          * @return A pointer to this user's connect class.
 661          */
 662         ConnectClass* GetClass() const { return MyClass; }
 663
 664         /** Call this method to find the matching \<connect> for a user, and to check them against it.
 665          */
 666         void CheckClass(bool clone_count = true);
 667
 668         /** Server address and port that this user is connected to.
 669          */
 670         irc::sockets::sockaddrs server_sa;
 671
 672         /**
 673          * @return The port number of this user.
 674          */
 675         int GetServerPort();
 676
 677         /** Recursion fix: user is out of SendQ and will be quit as soon as possible.
 678          * This can't be handled normally because QuitUser itself calls Write on other
 679          * users, which could trigger their SendQ to overrun.
 680          */
 681         unsigned int quitting_sendq:1;
 682
 683         /** has the user responded to their previous ping?
 684          */
 685         unsigned int lastping:1;
 686
 687         /** This is true if the user matched an exception (E:Line). It is used to save time on ban checks.
 688          */
 689         unsigned int exempt:1;
 690
 691         /** Used by PING checking code
 692          */
 693         time_t nping;
 694
 695         /** Time that the connection last sent a message, used to calculate idle time
 696          */
 697         time_t idle_lastmsg;
 698
 699         /** This value contains how far into the penalty threshold the user is.
 700          * This is used either to enable fake lag or for excess flood quits
 701          */
 702         unsigned int CommandFloodPenalty;
 703
 704         static already_sent_t already_sent_id;
 705         already_sent_t already_sent;
 706
 707         /** Check if the user matches a G or K line, and disconnect them if they do.
 708          * @param doZline True if ZLines should be checked (if IP has changed since initial connect)
 709          * Returns true if the user matched a ban, false else.
 710          */
 711         bool CheckLines(bool doZline = false);
 712
 713         /** Use this method to fully connect a user.
 714          * This will send the message of the day, check G/K/E lines, etc.
 715          */
 716         void FullConnect();
 717
 718         /** Set the connect class to which this user belongs to.
 719          * @param explicit_name Set this string to tie the user to a specific class name. Otherwise, the class is fitted by checking \<connect> tags from the configuration file.
 720          * @return A reference to this user's current connect class.
 721          */
 722         void SetClass(const std::string &explicit_name = "");
 723
 724         bool SetClientIP(const char* sip, bool recheck_eline = true);
 725
 726         void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
 727
 728         void SendText(const std::string& line);
 729         void Write(const std::string& text);
 730         void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
 731
 732         /** Returns the list of channels this user has been invited to but has not yet joined.
 733          * @return A list of channels the user is invited to
 734          */
 735         InviteList& GetInviteList();
 736
 737         /** Returns true if a user is invited to a channel.
 738          * @param chan A channel to look up
 739          * @return True if the user is invited to the given channel
 740          */
 741         bool IsInvited(Channel* chan) { return (Invitation::Find(chan, this) != NULL); }
 742
 743         /** Removes a channel from a users invite list.
 744          * This member function is called on successfully joining an invite only channel
 745          * to which the user has previously been invited, to clear the invitation.
 746          * @param chan The channel to remove the invite to
 747          * @return True if the user was invited to the channel and the invite was erased, false if the user wasn't invited
 748          */
 749         bool RemoveInvite(Channel* chan);
 750
 751         void RemoveExpiredInvites();
 752
 753         /** Returns true or false for if a user can execute a privilaged oper command.
 754          * This is done by looking up their oper type from User::oper, then referencing
 755          * this to their oper classes and checking the commands they can execute.
 756          * @param command A command (should be all CAPS)
 757          * @return True if this user can execute the command
 758          */
 759         bool HasPermission(const std::string &command);
 760
 761         /** Returns true if a user has a given permission.
 762          * This is used to check whether or not users may perform certain actions which admins may not wish to give to
 763          * all operators, yet are not commands. An example might be oper override, mass messaging (/notice $*), etc.
 764          *
 765          * @param privstr The priv to chec, e.g. "users/override/topic". These are loaded free-form from the config file.
 766          * @param noisy If set to true, the user is notified that they do not have the specified permission where applicable. If false, no notification is sent.
 767          * @return True if this user has the permission in question.
 768          */
 769         bool HasPrivPermission(const std::string &privstr, bool noisy = false);
 770
 771         /** Returns true or false if a user can set a privileged user or channel mode.
 772          * This is done by looking up their oper type from User::oper, then referencing
 773          * this to their oper classes, and checking the modes they can set.
 774          * @param mode The mode the check
 775          * @param type ModeType (MODETYPE_CHANNEL or MODETYPE_USER).
 776          * @return True if the user can set or unset this mode.
 777          */
 778         bool HasModePermission(unsigned char mode, ModeType type);
 779 };
 780
 781 class CoreExport RemoteUser : public User
 782 {
 783  public:
 784         RemoteUser(const std::string& uid, Server* srv) : User(uid, srv, USERTYPE_REMOTE)
 785         {
 786         }
 787         virtual void SendText(const std::string& line);
 788 };
 789
 790 class CoreExport FakeUser : public User
 791 {
 792  public:
 793         FakeUser(const std::string& uid, Server* srv) : User(uid, srv, USERTYPE_SERVER)
 794         {
 795                 nick = srv->GetName();
 796         }
 797
 798         FakeUser(const std::string& uid, const std::string& sname, const std::string& sdesc)
 799                 : User(uid, new Server(sname, sdesc), USERTYPE_SERVER)
 800         {
 801                 nick = sname;
 802         }
 803
 804         virtual CullResult cull();
 805         virtual void SendText(const std::string& line);
 806         virtual const std::string& GetFullHost();
 807         virtual const std::string& GetFullRealHost();
 808 };
 809
 810 /* Faster than dynamic_cast */
 811 /** Is a local user */
 812 inline LocalUser* IS_LOCAL(User* u)
 813 {
 814         return u->usertype == USERTYPE_LOCAL ? static_cast<LocalUser*>(u) : NULL;
 815 }
 816 /** Is a remote user */
 817 inline RemoteUser* IS_REMOTE(User* u)
 818 {
 819         return u->usertype == USERTYPE_REMOTE ? static_cast<RemoteUser*>(u) : NULL;
 820 }
 821 /** Is a server fakeuser */
 822 inline FakeUser* IS_SERVER(User* u)
 823 {
 824         return u->usertype == USERTYPE_SERVER ? static_cast<FakeUser*>(u) : NULL;
 825 }
 826
 827 inline bool User::IsModeSet(ModeHandler* mh)
 828 {
 829         return (modes[mh->GetId()]);
 830 }
 831
 832 inline bool User::IsModeSet(UserModeReference& moderef)
 833 {
 834         if (!moderef)
 835                 return false;
 836         return IsModeSet(*moderef);
 837 }
 838
 839 inline void User::SetMode(ModeHandler* mh, bool value)
 840 {
 841         modes[mh->GetId()] = value;
 842 }