X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fusers.h;h=1d8e918aa2b88dd11915a2951b900cad0dc44574;hb=e2b1ad588d34c3d1d0e4e330acef7ca177b13daf;hp=30e524e8559d13f0e115aece301f1cdcb815bca3;hpb=33ed72a1dfae595132dd50c760b6a312ef2ce8fe;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/users.h b/include/users.h index 30e524e85..1d8e918aa 100644 --- a/include/users.h +++ b/include/users.h @@ -18,17 +18,13 @@ #define __USERS_H__ #include - -#ifdef THREADED_DNS -#include -#endif - #include "inspircd_config.h" #include "socket.h" #include "channels.h" #include "inspstring.h" #include "connection.h" #include "hashcomp.h" +#include "dns.h" #include "cull_list.h" enum ChanStatus { @@ -45,13 +41,21 @@ enum ClassTypes { /** RFC1459 channel modes * */ -enum ChannelModes { +enum UserModes { UM_SERVERNOTICE = 's'-65, UM_WALLOPS = 'w'-65, UM_INVISIBLE = 'i'-65, UM_OPERATOR = 'o'-65, }; +enum RegistrationState { + REG_NONE = 0, /* Has sent nothing */ + REG_USER = 1, /* Has sent USER */ + REG_NICK = 2, /* Has sent NICK */ + REG_NICKUSER = 3, /* Bitwise combination of REG_NICK and REG_USER */ + REG_ALL = 7 /* REG_NICKUSER plus next bit along */ +}; + /** Holds a channel name to which a user has been invited. */ class Invited : public classbase @@ -61,6 +65,27 @@ class Invited : public classbase }; + +class InspIRCd; + +/** Derived from Resolver, and performs user forward/reverse lookups. + */ +class UserResolver : public Resolver +{ + private: + /** User this class is 'attached' to. + */ + userrec* bound_user; + int bound_fd; + bool fwd; + public: + UserResolver(InspIRCd* Instance, userrec* user, std::string to_resolve, bool forward); + + void OnLookupComplete(const std::string &result); + void OnError(ResolverError e, const std::string &errormessage); +}; + + /** Holds information relevent to <connect allow> and <connect deny> tags in the config file. */ class ConnectClass : public classbase @@ -133,11 +158,30 @@ typedef std::vector UserChanList; class userrec : public connection { private: + /** Pointer to creator + */ + InspIRCd* ServerInstance; /** A list of channels the user has a pending invite to. */ InvitedList invites; public: + /** Resolvers for looking up this users hostname + */ + UserResolver* res_forward; + + /** Resolvers for looking up this users hostname + */ + UserResolver* res_reverse; + + /** Stored reverse lookup from res_forward + */ + std::string stored_host; + + /** Starts a DNS lookup of the user's IP. + * When complete, sets userrec::dns_done to true. + */ + void StartDNSLookup(); /** The users nickname. * An invalid nickname indicates an unregistered connection prior to the NICK command. @@ -170,6 +214,13 @@ class userrec : public connection */ char modes[64]; + /** What snomasks are set on this user. + * This functions the same as the above modes. + */ + char snomasks[64]; + + /** Channels this user is on, and the permissions they have there + */ UserChanList chans; /** The server the user is connected to. @@ -233,7 +284,35 @@ class userrec : public connection /** IPV4 ip address */ - in_addr ip4; + sockaddr* ip; + + /** Initialize the clients sockaddr + * @param protocol_family The protocol family of the IP address, AF_INET or AF_INET6 + * @param ip A human-readable IP address for this user matching the protcol_family + * @param port The port number of this user or zero for a remote user + */ + void SetSockAddr(int protocol_family, const char* ip, int port); + + /** Get port number from sockaddr + * @return The port number of this user. + */ + int GetPort(); + + /** Get protocol family from sockaddr + * @return The protocol family of this user, either AF_INET or AF_INET6 + */ + int GetProtocolFamily(); + + /** Get IP string from sockaddr, using static internal buffer + * @return The IP string + */ + const char* GetIPString(); + + /** Get IP string from sockaddr, using caller-specified buffer + * @param buf A buffer to use + * @return The IP string + */ + const char* GetIPString(char* buf); /* Write error string */ @@ -248,12 +327,14 @@ class userrec : public connection long recvqmax; /** Default constructor + * @throw Nothing at present */ - userrec(); + userrec(InspIRCd* Instance); /** Returns the full displayed host of the user * This member function returns the hostname of the user as seen by other users * on the server, in nick!ident&at;host form. + * @return The full masked host of the user */ virtual char* GetFullHost(); @@ -261,44 +342,97 @@ class userrec : public connection * This member function returns the hostname of the user as seen by other users * on the server, in nick!ident&at;host form. If any form of hostname cloaking is in operation, * e.g. through a module, then this method will ignore it and return the true hostname. + * @return The full real host of the user */ virtual char* GetFullRealHost(); + + /** Create a displayable mode string for this users snomasks + * @return The notice mask character sequence + */ + const char* FormatNoticeMasks(); + + /** Process a snomask modifier string, e.g. +abc-de + * @param sm A sequence of notice mask characters + * @return True if the notice masks were successfully applied + */ + bool userrec::ProcessNoticeMasks(const char *sm); + + /** Returns true if a notice mask is set + * @param sm A notice mask character to check + * @return True if the notice mask is set + */ + bool IsNoticeMaskSet(unsigned char sm); + + /** Changed a specific notice mask value + * @param sm The server notice mask to change + * @param value An on/off value for this mask + */ + void SetNoticeMask(unsigned char sm, bool value); + + /** Create a displayable mode string for this users umodes + * @param The mode string + */ + const char* FormatModes(); + + /** Returns true if a specific mode is set + * @param m The user mode + * @return True if the mode is set + */ + bool IsModeSet(unsigned char m); + + /** Set a specific usermode to on or off + * @param m The user mode + * @param value On or off setting of the mode + */ + void SetMode(unsigned char m, bool value); /** Returns true if a user is invited to a channel. + * @param channel A channel name to look up + * @return True if the user is invited to the given channel */ virtual bool IsInvited(irc::string &channel); /** Adds a channel to a users invite list (invites them to a channel) + * @param channel A channel name to add */ virtual void InviteTo(irc::string &channel); /** Removes a channel from a users invite list. * This member function is called on successfully joining an invite only channel * to which the user has previously been invited, to clear the invitation. + * @param channel The channel to remove the invite to */ virtual void RemoveInvite(irc::string &channel); /** Returns true or false for if a user can execute a privilaged oper command. * This is done by looking up their oper type from userrec::oper, then referencing * this to their oper classes and checking the commands they can execute. + * @param command A command (should be all CAPS) + * @return True if this user can execute the command */ bool HasPermission(const std::string &command); /** Calls read() to read some data for this user using their fd. + * @param buffer The buffer to read into + * @param size The size of data to read + * @return The number of bytes read, or -1 if an error occured. */ int ReadData(void* buffer, size_t size); - /** This method adds data to the buffer of the user. + /** This method adds data to the read buffer of the user. * The buffer can grow to any size within limits of the available memory, * managed by the size of a std::string, however if any individual line in * the buffer grows over 600 bytes in length (which is 88 chars over the * RFC-specified limit per line) then the method will return false and the * text will not be inserted. + * @param a The string to add to the users read buffer + * @return True if the string was successfully added to the read buffer */ bool AddBuffer(const std::string &a); /** This method returns true if the buffer contains at least one carriage return * character (e.g. one complete line may be read) + * @return True if there is at least one complete line in the users buffer */ bool BufferIsReady(); @@ -312,6 +446,7 @@ class userrec : public connection * multiple lines if they are available. The results of this function if there * are no lines to be read are unknown, always use BufferIsReady() to check if * it is ok to read the buffer before calling GetBuffer(). + * @return The string at the tail end of this users buffer */ std::string GetBuffer(); @@ -319,11 +454,13 @@ class userrec : public connection * of a client may occur at an inopportune time such as half way through /LIST output. * The WriteErrors of clients are checked at a more ideal time (in the mainloop) and * errored clients purged. + * @param error The error string to set. */ void SetWriteError(const std::string &error); /** Returns the write error which last occured on this connection or an empty string * if none occured. + * @return The error string which has occured for this user */ const char* GetWriteError(); @@ -331,6 +468,7 @@ class userrec : public connection * You may add any amount of text up to this users sendq value, if you exceed the * sendq value, SetWriteError() will be called to set the users error string to * "SendQ exceeded", and further buffer adds will be dropped. + * @param data The data to add to the write buffer */ void AddWriteBuf(const std::string &data); @@ -343,16 +481,19 @@ class userrec : public connection void FlushWriteBuf(); /** Returns the list of channels this user has been invited to but has not yet joined. + * @return A list of channels the user is invited to */ InvitedList* GetInviteList(); /** Creates a wildcard host. * Takes a buffer to use and fills the given buffer with the host in the format *!*@hostname + * @return The wildcarded hostname in *!*@host form */ char* MakeWildHost(); /** Creates a host. * Takes a buffer to use and fills the given buffer with the host in the format nick!user@host + * @param Buffer to fill with host information */ void MakeHost(char* nhost); @@ -360,55 +501,220 @@ class userrec : public connection */ void CloseSocket(); - /** Default destructor + /** Disconnect a user gracefully + * @param user The user to remove + * @param r The quit reason */ - virtual ~userrec(); + static void QuitUser(InspIRCd* Instance, userrec *user, const std::string &r); -#ifdef THREADED_DNS - /** Thread used for threaded lookups + /** Add the user to WHOWAS system */ - pthread_t dnsthread; -#endif -}; + void AddToWhoWas(); -/** Used to hold WHOWAS information - */ -class WhoWasGroup -{ - public: - char* host; - char* dhost; - char* ident; - const char* server; - char* gecos; - time_t signon; + /** Oper up the user using the given opertype. + * This will also give the +o usermode. + * @param opertype The oper type to oper as + */ + void Oper(const std::string &opertype); + + /** Use this method to fully connect a user. + * This will send the message of the day, check G/K/E lines, etc. + * @param Goners If the user is disconnected by this method call, the + * value of 'this' will be pushed onto this CullList. This is used by + * the core to connect many users in rapid succession without invalidating + * iterators. + */ + void FullConnect(CullList* Goners); + + /** Change this users hash key to a new string. + * You should not call this function directly. It is used by the core + * to update the users hash entry on a nickchange. + * @param New new user_hash key + * @return Pointer to userrec in hash (usually 'this') + */ + userrec* UpdateNickHash(const char* New); + + /** Force a nickname change. + * If the nickname change fails (for example, because the nick in question + * already exists) this function will return false, and you must then either + * output an error message, or quit the user for nickname collision. + * @param newnick The nickname to change to + * @return True if the nickchange was successful. + */ + bool ForceNickChange(const char* newnick); + + /** Add a client to the system. + * This will create a new userrec, insert it into the user_hash, + * initialize it as not yet registered, and add it to the socket engine. + */ + static void AddClient(InspIRCd* Instance, int socket, int port, bool iscached, insp_inaddr ip); + + /** Oper down. + * This will clear the +o usermode and unset the user's oper type + */ + void UnOper(); + + /** Return the number of global clones of this user + */ + long GlobalCloneCount(); + + /** Return the number of local clones of this user + */ + long LocalCloneCount(); + + /** Write text to this user, appending CR/LF. + * @param text A std::string to send to the user + */ + void Write(const std::string &text); + + /** Write text to this user, appending CR/LF. + * @param text The format string for text to send to the user + * @param ... POD-type format arguments + */ + void Write(const char *text, ...); + + /** Write text to this user, appending CR/LF and prepending :server.name + * @param text A std::string to send to the user + */ + void WriteServ(const std::string& text); + + /** Write text to this user, appending CR/LF and prepending :server.name + * @param text The format string for text to send to the user + * @param ... POD-type format arguments + */ + void WriteServ(const char* text, ...); + + /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter. + * @param user The user to prepend the :nick!user@host of + * @param text A std::string to send to the user + */ + void WriteFrom(userrec *user, const std::string &text); + + /** Write text to this user, appending CR/LF and prepending :nick!user@host of the user provided in the first parameter. + * @param user The user to prepend the :nick!user@host of + * @param text The format string for text to send to the user + * @param ... POD-type format arguments + */ + void WriteFrom(userrec *user, const char* text, ...); + + /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host. + * @param dest The user to route the message to + * @param text A std::string to send to the user + */ + void WriteTo(userrec *dest, const std::string &data); + + /** Write text to the user provided in the first parameter, appending CR/LF, and prepending THIS user's :nick!user@host. + * @param dest The user to route the message to + * @param text The format string for text to send to the user + * @param ... POD-type format arguments + */ + void WriteTo(userrec *dest, const char *data, ...); + + /** Write to all users that can see this user (including this user in the list), appending CR/LF + * @param text A std::string to send to the users + */ + void WriteCommon(const std::string &text); + + /** Write to all users that can see this user (including this user in the list), appending CR/LF + * @param text The format string for text to send to the users + * @param ... POD-type format arguments + */ + void WriteCommon(const char* text, ...); + + /** Write to all users that can see this user (not including this user in the list), appending CR/LF + * @param text The format string for text to send to the users + * @param ... POD-type format arguments + */ + void WriteCommonExcept(const char* text, ...); + + /** Write to all users that can see this user (not including this user in the list), appending CR/LF + * @param text A std::string to send to the users + */ + void WriteCommonExcept(const std::string &text); + + void WriteWallOps(const char* text, ...); + + void WriteWallOps(const std::string &text); + + bool SharesChannelWith(userrec *other); + + bool ChangeDisplayedHost(const char* host); - WhoWasGroup(userrec* user); - ~WhoWasGroup(); + bool ChangeName(const char* gecos); + + int CountChannels(); + + void NoticeAll(char* text, ...); + + std::string ChannelList(userrec* source); + + void SplitChanList(userrec* dest, const std::string &cl); + + /** Default destructor + */ + virtual ~userrec(); }; -typedef std::deque whowas_set; -typedef std::map whowas_users; -void AddOper(userrec* user); -void DeleteOper(userrec* user); -void kill_link(userrec *user,const char* r); -void kill_link_silent(userrec *user,const char* r); -void AddWhoWas(userrec* u); -void MaintainWhoWas(time_t TIME); -void AddClient(int socket, int port, bool iscached, in_addr ip4); -void FullConnectUser(userrec* user, CullList* Goners); -userrec* ReHashNick(char* Old, char* New); -void force_nickchange(userrec* user,const char* newnick); +namespace irc +{ + /** Holds whowas related functions and classes + */ + namespace whowas + { + + /** Used to hold WHOWAS information + */ + class WhoWasGroup : public classbase + { + public: + /** Real host + */ + char* host; + /** Displayed host + */ + char* dhost; + /** Ident + */ + char* ident; + /** Server name + */ + const char* server; + /** Fullname (GECOS) + */ + char* gecos; + /** Signon time + */ + time_t signon; + + /** Initialize this WhoQasFroup with a user + */ + WhoWasGroup(userrec* user); + /** Destructor + */ + ~WhoWasGroup(); + }; + + /** A group of users related by nickname + */ + typedef std::deque whowas_set; + + /** Sets of users in the whowas system + */ + typedef std::map whowas_users; + + /** Called every hour by the core to remove expired entries + */ + void MaintainWhoWas(time_t TIME); + }; +}; /* Configuration callbacks */ -bool InitTypes(const char* tag); -bool InitClasses(const char* tag); -bool DoType(const char* tag, char** entries, void** values, int* types); -bool DoClass(const char* tag, char** entries, void** values, int* types); -bool DoneClassesAndTypes(const char* tag); - -long FindMatchingGlobal(userrec* user); -long FindMatchingLocal(userrec* user); +class ServerConfig; +bool InitTypes(ServerConfig* conf, const char* tag); +bool InitClasses(ServerConfig* conf, const char* tag); +bool DoType(ServerConfig* conf, const char* tag, char** entries, void** values, int* types); +bool DoClass(ServerConfig* conf, const char* tag, char** entries, void** values, int* types); +bool DoneClassesAndTypes(ServerConfig* conf, const char* tag); #endif