include/users.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 __USERS_H__
  18 #define __USERS_H__
  19
  20 #include <string>
  21 #include "inspircd_config.h"
  22 #include "socket.h"
  23 #include "channels.h"
  24 #include "inspstring.h"
  25 #include "connection.h"
  26 #include "hashcomp.h"
  27 #include "dns.h"
  28 #include "cull_list.h"
  29
  30 enum ChanStatus {
  31         STATUS_OP     = 4,
  32         STATUS_HOP    = 2,
  33         STATUS_VOICE  = 1,
  34         STATUS_NORMAL = 0
  35 };
  36
  37 enum ClassTypes {
  38         CC_ALLOW = 0,
  39         CC_DENY  = 1
  40 };
  41
  42 /** RFC1459 channel modes
  43  *  */
  44 enum UserModes {
  45         UM_SERVERNOTICE = 's'-65,
  46         UM_WALLOPS = 'w'-65,
  47         UM_INVISIBLE = 'i'-65,
  48         UM_OPERATOR = 'o'-65,
  49         UM_SNOMASK = 'n'-65,
  50 };
  51
  52 enum RegistrationState {
  53         REG_NONE = 0,           /* Has sent nothing */
  54         REG_USER = 1,           /* Has sent USER */
  55         REG_NICK = 2,           /* Has sent NICK */
  56         REG_NICKUSER = 3,       /* Bitwise combination of REG_NICK and REG_USER */
  57         REG_ALL = 7             /* REG_NICKUSER plus next bit along */
  58 };
  59
  60 /** Holds a channel name to which a user has been invited.
  61  */
  62 class Invited : public classbase
  63 {
  64  public:
  65          irc::string channel;
  66 };
  67
  68
  69
  70 class InspIRCd;
  71
  72 /** Derived from Resolver, and performs user forward/reverse lookups.
  73  */
  74 class UserResolver : public Resolver
  75 {
  76  private:
  77         /** User this class is 'attached' to.
  78          */
  79         userrec* bound_user;
  80         int bound_fd;
  81         bool fwd;
  82  public:
  83         UserResolver(InspIRCd* Instance, userrec* user, std::string to_resolve, bool forward);
  84
  85         void OnLookupComplete(const std::string &result);
  86         void OnError(ResolverError e, const std::string &errormessage);
  87 };
  88
  89
  90 /** Holds information relevent to &lt;connect allow&gt; and &lt;connect deny&gt; tags in the config file.
  91  */
  92 class ConnectClass : public classbase
  93 {
  94  public:
  95         /** Type of line, either CC_ALLOW or CC_DENY
  96          */
  97         char type;
  98         /** Max time to register the connection in seconds
  99          */
 100         int registration_timeout;
 101         /** Number of lines in buffer before excess flood is triggered
 102          */
 103         int flood;
 104         /** Host mask for this line
 105          */
 106         std::string host;
 107         /** Number of seconds between pings for this line
 108          */
 109         int pingtime;
 110         /** (Optional) Password for this line
 111          */
 112         std::string pass;
 113
 114         /** Threshold value for flood disconnect
 115          */
 116         int threshold;
 117
 118         /** Maximum size of sendq for users in this class (bytes)
 119          */
 120         long sendqmax;
 121
 122         /** Maximum size of recvq for users in this class (bytes)
 123          */
 124         long recvqmax;
 125
 126         /** Local max when connecting by this connection class
 127          */
 128         long maxlocal;
 129
 130         /** Global max when connecting by this connection class
 131          */
 132         long maxglobal;
 133
 134         ConnectClass() : registration_timeout(0), flood(0), host(""), pingtime(0), pass(""), threshold(0), sendqmax(0), recvqmax(0)
 135         {
 136         }
 137 };
 138
 139 /** Holds a complete list of all channels to which a user has been invited and has not yet joined.
 140  */
 141 typedef std::vector<Invited> InvitedList;
 142
 143
 144
 145 /** Holds a complete list of all allow and deny tags from the configuration file (connection classes)
 146  */
 147 typedef std::vector<ConnectClass> ClassVector;
 148
 149 /** Typedef for the list of user-channel records for a user
 150  */
 151 typedef std::vector<ucrec*> UserChanList;
 152
 153 /** Holds all information about a user
 154  * This class stores all information about a user connected to the irc server. Everything about a
 155  * connection is stored here primarily, from the user's socket ID (file descriptor) through to the
 156  * user's nickname and hostname. Use the FindNick method of the InspIRCd class to locate a specific user
 157  * by nickname, or the FindDescriptor method of the InspIRCd class to find a specific user by their
 158  * file descriptor value.
 159  */
 160 class userrec : public connection
 161 {
 162  private:
 163         /** Pointer to creator.
 164          * This is required to make use of core functions
 165          * from within the userrec class.
 166          */
 167         InspIRCd* ServerInstance;
 168
 169         /** A list of channels the user has a pending invite to.
 170          * Upon INVITE channels are added, and upon JOIN, the
 171          * channels are removed from this list.
 172          */
 173         InvitedList invites;
 174
 175         /** Number of channels this user is currently on
 176          */
 177         unsigned int ChannelCount;
 178  public:
 179         /** Resolvers for looking up this users IP address
 180          * This will occur if and when res_reverse completes.
 181          * When this class completes its lookup, userrec::dns_done
 182          * will be set from false to true.
 183          */
 184         UserResolver* res_forward;
 185
 186         /** Resolvers for looking up this users hostname
 187          * This is instantiated by userrec::StartDNSLookup(),
 188          * and on success, instantiates userrec::res_reverse.
 189          */
 190         UserResolver* res_reverse;
 191
 192         /** Stored reverse lookup from res_forward
 193          */
 194         std::string stored_host;
 195
 196         /** Starts a DNS lookup of the user's IP.
 197          * This will cause two UserResolver classes to be instantiated.
 198          * When complete, these objects set userrec::dns_done to true.
 199          */
 200         void StartDNSLookup();
 201
 202         /** The users nickname.
 203          * An invalid nickname indicates an unregistered connection prior to the NICK command.
 204          * Use InspIRCd::IsNick() to validate nicknames.
 205          */
 206         char nick[NICKMAX];
 207
 208         /** The users ident reply.
 209          * Two characters are added to the user-defined limit to compensate for the tilde etc.
 210          */
 211         char ident[IDENTMAX+2];
 212
 213         /** The host displayed to non-opers (used for cloaking etc).
 214          * This usually matches the value of userrec::host.
 215          */
 216         char dhost[65];
 217
 218         /** The users full name (GECOS).
 219          */
 220         char fullname[MAXGECOS+1];
 221
 222         /** The user's mode list.
 223          * This is NOT a null terminated string! In the 1.1 version of InspIRCd
 224          * this is an array of values in a similar way to channel modes.
 225          * A value of 1 in field (modeletter-65) indicates that the mode is
 226          * set, for example, to work out if mode +s is set, we  check the field
 227          * userrec::modes['s'-65] != 0.
 228          * The following RFC characters o, w, s, i have constants defined via an
 229          * enum, such as UM_SERVERNOTICE and UM_OPETATOR.
 230          */
 231         char modes[64];
 232
 233         /** What snomasks are set on this user.
 234          * This functions the same as the above modes.
 235          */
 236         char snomasks[64];
 237
 238         /** Channels this user is on, and the permissions they have there
 239          */
 240         UserChanList chans;
 241
 242         /** The server the user is connected to.
 243          */
 244         const char* server;
 245
 246         /** The user's away message.
 247          * If this string is empty, the user is not marked as away.
 248          */
 249         char awaymsg[MAXAWAY+1];
 250
 251         /** Number of lines the user can place into the buffer
 252          * (up to the global NetBufferSize bytes) before they
 253          * are disconnected for excess flood
 254          */
 255         int flood;
 256
 257         /** Number of seconds this user is given to send USER/NICK
 258          * If they do not send their details in this time limit they
 259          * will be disconnected
 260          */
 261         unsigned int timeout;
 262
 263         /** The oper type they logged in as, if they are an oper.
 264          * This is used to check permissions in operclasses, so that
 265          * we can say 'yay' or 'nay' to any commands they issue.
 266          * The value of this is the value of a valid 'type name=' tag.
 267          */
 268         char oper[NICKMAX];
 269
 270         /** True when DNS lookups are completed.
 271          * The UserResolver classes res_forward and res_reverse will
 272          * set this value once they complete.
 273          */
 274         bool dns_done;
 275
 276         /** Number of seconds between PINGs for this user (set from &lt;connect:allow&gt; tag
 277          */
 278         unsigned int pingmax;
 279
 280         /** Password specified by the user when they registered.
 281          * This is stored even if the <connect> block doesnt need a password, so that
 282          * modules may check it.
 283          */
 284         char password[64];
 285
 286         /** User's receive queue.
 287          * Lines from the IRCd awaiting processing are stored here.
 288          * Upgraded april 2005, old system a bit hairy.
 289          */
 290         std::string recvq;
 291
 292         /** User's send queue.
 293          * Lines waiting to be sent are stored here until their buffer is flushed.
 294          */
 295         std::string sendq;
 296
 297         /** Flood counters - lines received
 298          */
 299         int lines_in;
 300
 301         /** Flood counters - time lines_in is due to be reset
 302          */
 303         time_t reset_due;
 304
 305         /** Flood counters - Highest value lines_in may reach before the user gets disconnected
 306          */
 307         long threshold;
 308
 309         /** IPV4 or IPV6 ip address
 310          */
 311         sockaddr* ip;
 312
 313         /** Initialize the clients sockaddr
 314          * @param protocol_family The protocol family of the IP address, AF_INET or AF_INET6
 315          * @param ip A human-readable IP address for this user matching the protcol_family
 316          * @param port The port number of this user or zero for a remote user
 317          */
 318         void SetSockAddr(int protocol_family, const char* ip, int port);
 319
 320         /** Get port number from sockaddr
 321          * @return The port number of this user.
 322          */
 323         int GetPort();
 324
 325         /** Get protocol family from sockaddr
 326          * @return The protocol family of this user, either AF_INET or AF_INET6
 327          */
 328         int GetProtocolFamily();
 329
 330         /** Get IP string from sockaddr, using static internal buffer
 331          * @return The IP string
 332          */
 333         const char* GetIPString();
 334
 335         /** Get IP string from sockaddr, using caller-specified buffer
 336          * @param buf A buffer to use
 337          * @return The IP string
 338          */
 339         const char* GetIPString(char* buf);
 340
 341         /* Write error string
 342          */
 343         std::string WriteError;
 344
 345         /** Maximum size this user's sendq can become
 346          */
 347         long sendqmax;
 348
 349         /** Maximum size this user's recvq can become
 350          */
 351         long recvqmax;
 352
 353         /** Default constructor
 354          * @throw Nothing at present
 355          */
 356         userrec(InspIRCd* Instance);
 357
 358         /** Returns the full displayed host of the user
 359          * This member function returns the hostname of the user as seen by other users
 360          * on the server, in nick!ident&at;host form.
 361          * @return The full masked host of the user
 362          */
 363         virtual char* GetFullHost();
 364
 365         /** Returns the full real host of the user
 366          * This member function returns the hostname of the user as seen by other users
 367          * on the server, in nick!ident&at;host form. If any form of hostname cloaking is in operation,
 368          * e.g. through a module, then this method will ignore it and return the true hostname.
 369          * @return The full real host of the user
 370          */
 371         virtual char* GetFullRealHost();
 372
 373         /** Create a displayable mode string for this users snomasks
 374          * @return The notice mask character sequence
 375          */
 376         const char* FormatNoticeMasks();
 377
 378         /** Process a snomask modifier string, e.g. +abc-de
 379          * @param sm A sequence of notice mask characters
 380          * @return The cleaned mode sequence which can be output,
 381          * e.g. in the above example if masks c and e are not
 382          * valid, this function will return +ab-d
 383          */
 384         std::string ProcessNoticeMasks(const char *sm);
 385
 386         /** Returns true if a notice mask is set
 387          * @param sm A notice mask character to check
 388          * @return True if the notice mask is set
 389          */
 390         bool IsNoticeMaskSet(unsigned char sm);
 391
 392         /** Changed a specific notice mask value
 393          * @param sm The server notice mask to change
 394          * @param value An on/off value for this mask
 395          */
 396         void SetNoticeMask(unsigned char sm, bool value);
 397
 398         /** Create a displayable mode string for this users umodes
 399          * @param The mode string
 400          */
 401         const char* FormatModes();
 402
 403         /** Returns true if a specific mode is set
 404          * @param m The user mode
 405          * @return True if the mode is set
 406          */
 407         bool IsModeSet(unsigned char m);
 408
 409         /** Set a specific usermode to on or off
 410          * @param m The user mode
 411          * @param value On or off setting of the mode
 412          */
 413         void SetMode(unsigned char m, bool value);
 414
 415         /** Returns true if a user is invited to a channel.
 416          * @param channel A channel name to look up
 417          * @return True if the user is invited to the given channel
 418          */
 419         virtual bool IsInvited(irc::string &channel);
 420
 421         /** Adds a channel to a users invite list (invites them to a channel)
 422          * @param channel A channel name to add
 423          */
 424         virtual void InviteTo(irc::string &channel);
 425
 426         /** Removes a channel from a users invite list.
 427          * This member function is called on successfully joining an invite only channel
 428          * to which the user has previously been invited, to clear the invitation.
 429          * @param channel The channel to remove the invite to
 430          */
 431         virtual void RemoveInvite(irc::string &channel);
 432
 433         /** Returns true or false for if a user can execute a privilaged oper command.
 434          * This is done by looking up their oper type from userrec::oper, then referencing
 435          * this to their oper classes and checking the commands they can execute.
 436          * @param command A command (should be all CAPS)
 437          * @return True if this user can execute the command
 438          */
 439         bool HasPermission(const std::string &command);
 440
 441         /** Calls read() to read some data for this user using their fd.
 442          * @param buffer The buffer to read into
 443          * @param size The size of data to read
 444          * @return The number of bytes read, or -1 if an error occured.
 445          */
 446         int ReadData(void* buffer, size_t size);
 447
 448         /** This method adds data to the read buffer of the user.
 449          * The buffer can grow to any size within limits of the available memory,
 450          * managed by the size of a std::string, however if any individual line in
 451          * the buffer grows over 600 bytes in length (which is 88 chars over the
 452          * RFC-specified limit per line) then the method will return false and the
 453          * text will not be inserted.
 454          * @param a The string to add to the users read buffer
 455          * @return True if the string was successfully added to the read buffer
 456          */
 457         bool AddBuffer(std::string a);
 458
 459         /** This method returns true if the buffer contains at least one carriage return
 460          * character (e.g. one complete line may be read)
 461          * @return True if there is at least one complete line in the users buffer
 462          */
 463         bool BufferIsReady();
 464
 465         /** This function clears the entire buffer by setting it to an empty string.
 466          */
 467         void ClearBuffer();
 468
 469         /** This method returns the first available string at the tail end of the buffer
 470          * and advances the tail end of the buffer past the string. This means it is
 471          * a one way operation in a similar way to strtok(), and multiple calls return
 472          * multiple lines if they are available. The results of this function if there
 473          * are no lines to be read are unknown, always use BufferIsReady() to check if
 474          * it is ok to read the buffer before calling GetBuffer().
 475          * @return The string at the tail end of this users buffer
 476          */
 477         std::string GetBuffer();
 478
 479         /** Sets the write error for a connection. This is done because the actual disconnect
 480          * of a client may occur at an inopportune time such as half way through /LIST output.
 481          * The WriteErrors of clients are checked at a more ideal time (in the mainloop) and
 482          * errored clients purged.
 483          * @param error The error string to set.
 484          */
 485         void SetWriteError(const std::string &error);
 486
 487         /** Returns the write error which last occured on this connection or an empty string
 488          * if none occured.
 489          * @return The error string which has occured for this user
 490          */
 491         const char* GetWriteError();
 492
 493         /** Adds to the user's write buffer.
 494          * You may add any amount of text up to this users sendq value, if you exceed the
 495          * sendq value, SetWriteError() will be called to set the users error string to
 496          * "SendQ exceeded", and further buffer adds will be dropped.
 497          * @param data The data to add to the write buffer
 498          */
 499         void AddWriteBuf(const std::string &data);
 500
 501         /** Flushes as much of the user's buffer to the file descriptor as possible.
 502          * This function may not always flush the entire buffer, rather instead as much of it
 503          * as it possibly can. If the send() call fails to send the entire buffer, the buffer
 504          * position is advanced forwards and the rest of the data sent at the next call to
 505          * this method.
 506          */
 507         void FlushWriteBuf();
 508
 509         /** Returns the list of channels this user has been invited to but has not yet joined.
 510          * @return A list of channels the user is invited to
 511          */
 512         InvitedList* GetInviteList();
 513
 514         /** Creates a wildcard host.
 515          * Takes a buffer to use and fills the given buffer with the host in the format *!*@hostname
 516          * @return The wildcarded hostname in *!*@host form
 517          */
 518         char* MakeWildHost();
 519
 520         /** Creates a host.
 521          * Takes a buffer to use and fills the given buffer with the host in the format nick!user@host
 522          * @param Buffer to fill with host information
 523          */
 524         void MakeHost(char* nhost);
 525
 526         /** Shuts down and closes the user's socket
 527          * This will not cause the user to be deleted. Use InspIRCd::QuitUser for this,
 528          * which will call CloseSocket() for you.
 529          */
 530         void CloseSocket();
 531
 532         /** Disconnect a user gracefully
 533          * @param user The user to remove
 534          * @param r The quit reason
 535          * @return Although this function has no return type, on exit the user provided will no longer exist.
 536          */
 537         static void QuitUser(InspIRCd* Instance, userrec *user, const std::string &r);
 538
 539         /** Add the user to WHOWAS system
 540          */
 541         void AddToWhoWas();
 542
 543         /** Oper up the user using the given opertype.
 544          * This will also give the +o usermode.
 545          * @param opertype The oper type to oper as
 546          */
 547         void Oper(const std::string &opertype);
 548
 549         /** Use this method to fully connect a user.
 550          * This will send the message of the day, check G/K/E lines, etc.
 551          * @param Goners If the user is disconnected by this method call, the
 552          * value of 'this' will be pushed onto this CullList. This is used by
 553          * the core to connect many users in rapid succession without invalidating
 554          * iterators.
 555          * @param Goners a CullList to use for failed connections
 556          */
 557         void FullConnect(CullList* Goners);
 558
 559         /** Change this users hash key to a new string.
 560          * You should not call this function directly. It is used by the core
 561          * to update the users hash entry on a nickchange.
 562          * @param New new user_hash key
 563          * @return Pointer to userrec in hash (usually 'this')
 564          */
 565         userrec* UpdateNickHash(const char* New);
 566
 567         /** Force a nickname change.
 568          * If the nickname change fails (for example, because the nick in question
 569          * already exists) this function will return false, and you must then either
 570          * output an error message, or quit the user for nickname collision.
 571          * @param newnick The nickname to change to
 572          * @return True if the nickchange was successful.
 573          */
 574         bool ForceNickChange(const char* newnick);
 575
 576         /** Add a client to the system.
 577          * This will create a new userrec, insert it into the user_hash,
 578          * initialize it as not yet registered, and add it to the socket engine.
 579          * @param Instance a pointer to the server instance
 580          * @param socket The socket id (file descriptor) this user is on
 581          * @param port The port number this user connected on
 582          * @param iscached This variable is reserved for future use
 583          * @param ip The IP address of the user
 584          * @return This function has no return value, but a call to AddClient may remove the user.
 585          */
 586         static void AddClient(InspIRCd* Instance, int socket, int port, bool iscached, insp_inaddr ip);
 587
 588         /** Oper down.
 589          * This will clear the +o usermode and unset the user's oper type
 590          */
 591         void UnOper();
 592
 593         /** Return the number of global clones of this user
 594          * @return The global clone count of this user
 595          */
 596         long GlobalCloneCount();
 597
 598         /** Return the number of local clones of this user
 599          * @return The local clone count of this user
 600          */
 601         long LocalCloneCount();
 602
 603         /** Write text to this user, appending CR/LF.
 604          * @param text A std::string to send to the user
 605          */
 606         void Write(std::string text);
 607
 608         /** Write text to this user, appending CR/LF.
 609          * @param text The format string for text to send to the user
 610          * @param ... POD-type format arguments
 611          */
 612         void Write(const char *text, ...);
 613
 614         /** Write text to this user, appending CR/LF and prepending :server.name
 615          * @param text A std::string to send to the user
 616          */
 617         void WriteServ(const std::string& text);
 618
 619         /** Write text to this user, appending CR/LF and prepending :server.name
 620          * @param text The format string for text to send to the user
 621          * @param ... POD-type format arguments
 622          */
 623         void WriteServ(const char* text, ...);
 624
 625         /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter.
 626          * @param user The user to prepend the :nick!user@host of
 627          * @param text A std::string to send to the user
 628          */
 629         void WriteFrom(userrec *user, const std::string &text);
 630
 631         /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter.
 632          * @param user The user to prepend the :nick!user@host of
 633          * @param text The format string for text to send to the user
 634          * @param ... POD-type format arguments
 635          */
 636         void WriteFrom(userrec *user, const char* text, ...);
 637
 638         /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host.
 639          * @param dest The user to route the message to
 640          * @param text A std::string to send to the user
 641          */
 642         void WriteTo(userrec *dest, const std::string &data);
 643
 644         /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host.
 645          * @param dest The user to route the message to
 646          * @param text The format string for text to send to the user
 647          * @param ... POD-type format arguments
 648          */
 649         void WriteTo(userrec *dest, const char *data, ...);
 650
 651         /** Write to all users that can see this user (including this user in the list), appending CR/LF
 652          * @param text A std::string to send to the users
 653          */
 654         void WriteCommon(const std::string &text);
 655
 656         /** Write to all users that can see this user (including this user in the list), appending CR/LF
 657          * @param text The format string for text to send to the users
 658          * @param ... POD-type format arguments
 659          */
 660         void WriteCommon(const char* text, ...);
 661
 662         /** Write to all users that can see this user (not including this user in the list), appending CR/LF
 663          * @param text The format string for text to send to the users
 664          * @param ... POD-type format arguments
 665          */
 666         void WriteCommonExcept(const char* text, ...);
 667
 668         /** Write to all users that can see this user (not including this user in the list), appending CR/LF
 669          * @param text A std::string to send to the users
 670          */
 671         void WriteCommonExcept(const std::string &text);
 672
 673         /** Write a WALLOPS message from this user to all local opers.
 674          * If this user is not opered, the function will return without doing anything.
 675          * @param text The format string to send in the WALLOPS message
 676          * @param ... Format arguments
 677          */
 678         void WriteWallOps(const char* text, ...);
 679
 680         /** Write a WALLOPS message from this user to all local opers.
 681          * If this user is not opered, the function will return without doing anything.
 682          * @param text The text to send in the WALLOPS message
 683          */
 684         void WriteWallOps(const std::string &text);
 685
 686         /** Return true if the user shares at least one channel with another user
 687          * @param other The other user to compare the channel list against
 688          * @return True if the given user shares at least one channel with this user
 689          */
 690         bool SharesChannelWith(userrec *other);
 691
 692         /** Change the displayed host of a user.
 693          * ALWAYS use this function, rather than writing userrec::dhost directly,
 694          * as this triggers module events allowing the change to be syncronized to
 695          * remote servers. This will also emulate a QUIT and rejoin (where configured)
 696          * before setting their host field.
 697          * @param host The new hostname to set
 698          * @return True if the change succeeded, false if it didn't
 699          */
 700         bool ChangeDisplayedHost(const char* host);
 701
 702         /** Change the ident (username) of a user.
 703          * ALWAYS use this function, rather than writing userrec::ident directly,
 704          * as this correctly causes the user to seem to quit (where configured)
 705          * before setting their ident field.
 706          * @param host The new ident to set
 707          * @return True if the change succeeded, false if it didn't
 708          */
 709         bool ChangeIdent(const char* newident);
 710
 711         /** Change a users realname field.
 712          * ALWAYS use this function, rather than writing userrec::fullname directly,
 713          * as this triggers module events allowing the change to be syncronized to
 714          * remote servers.
 715          * @param gecos The user's new realname
 716          * @return True if the change succeeded, false if otherwise
 717          */
 718         bool ChangeName(const char* gecos);
 719
 720         /** Return the total number of channels this user is on.
 721          * @return The number of channels the user is on
 722          */
 723         int CountChannels();
 724
 725         /** Modify the number of channels this user is on (used by CountChannels).
 726          * Pass a positive number to increment the counter, or a negative number
 727          * to decrement it.
 728          */
 729         void ModChannelCount(int n);
 730
 731         /** Send a notice to all local users from this user
 732          * @param text The text format string to send
 733          * @param ... Format arguments
 734          */
 735         void NoticeAll(char* text, ...);
 736
 737         /** Compile a channel list for this user, and send it to the user 'source'
 738          * Used internally by WHOIS
 739          * @param The user to send the channel list to if it is not too long
 740          * @return This user's channel list
 741          */
 742         std::string ChannelList(userrec* source);
 743
 744         /** Split the channel list in cl which came from dest, and spool it to this user
 745          * Used internally by WHOIS
 746          * @param dest The user the original channel list came from
 747          * @param cl The  channel list as a string obtained from userrec::ChannelList()
 748          */
 749         void SplitChanList(userrec* dest, const std::string &cl);
 750
 751         /** Remove this user from all channels they are on, and delete any that are now empty.
 752          * This is used by QUIT, and will not send part messages!
 753          */
 754         void PurgeEmptyChannels();
 755
 756         /** Get the connect class which matches this user's host or IP address
 757          * @return A reference to this user's connect class
 758          */
 759         ConnectClass& GetClass();
 760
 761         /** Show the message of the day to this user
 762          */
 763         void ShowMOTD();
 764
 765         /** Show the server RULES file to this user
 766          */
 767         void ShowRULES();
 768
 769         /** Handle socket event.
 770          * From EventHandler class.
 771          */
 772         void HandleEvent(EventType et);
 773
 774         /** Default destructor
 775          */
 776         virtual ~userrec();
 777 };
 778
 779
 780 namespace irc
 781 {
 782         /** Holds whowas related functions and classes
 783          */
 784         namespace whowas
 785         {
 786
 787                 /** Used to hold WHOWAS information
 788                  */
 789                 class WhoWasGroup : public classbase
 790                 {
 791                  public:
 792                         /** Real host
 793                          */
 794                         char* host;
 795                         /** Displayed host
 796                          */
 797                         char* dhost;
 798                         /** Ident
 799                          */
 800                         char* ident;
 801                         /** Server name
 802                          */
 803                         const char* server;
 804                         /** Fullname (GECOS)
 805                          */
 806                         char* gecos;
 807                         /** Signon time
 808                          */
 809                         time_t signon;
 810
 811                         /** Initialize this WhoQasFroup with a user
 812                          */
 813                         WhoWasGroup(userrec* user);
 814                         /** Destructor
 815                          */
 816                         ~WhoWasGroup();
 817                 };
 818
 819                 /** A group of users related by nickname
 820                  */
 821                 typedef std::deque<WhoWasGroup*> whowas_set;
 822
 823                 /** Sets of users in the whowas system
 824                  */
 825                 typedef std::map<irc::string,whowas_set*> whowas_users;
 826
 827                 /** Called every hour by the core to remove expired entries
 828                  */
 829                 void MaintainWhoWas(time_t TIME);
 830         };
 831 };
 832
 833 /* Configuration callbacks */
 834 class ServerConfig;
 835 bool InitTypes(ServerConfig* conf, const char* tag);
 836 bool InitClasses(ServerConfig* conf, const char* tag);
 837 bool DoType(ServerConfig* conf, const char* tag, char** entries, void** values, int* types);
 838 bool DoClass(ServerConfig* conf, const char* tag, char** entries, void** values, int* types);
 839 bool DoneClassesAndTypes(ServerConfig* conf, const char* tag);
 840
 841 #endif