X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fusers.h;h=b9092b678fce7fc415b61bb0f57db523140ed121;hb=635cb9d65f6d7f6758ae8ed874da00c8d94b6e39;hp=03d94b28baf80b233befc7721c8ca56b8ea13c32;hpb=08f6f056667df63d1673bea959c73b75393113c6;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/users.h b/include/users.h index 03d94b28b..b9092b678 100644 --- a/include/users.h +++ b/include/users.h @@ -1,12 +1,22 @@ /* * InspIRCd -- Internet Relay Chat Daemon * - * Copyright (C) 2009 Daniel De Graaf - * Copyright (C) 2007-2008 Robin Burchell + * Copyright (C) 2019-2020 Matt Schatz + * Copyright (C) 2019 linuxdaemon + * Copyright (C) 2013 Daniel Vassdal + * Copyright (C) 2012-2016, 2018 Attila Molnar + * Copyright (C) 2012-2013, 2016-2020 Sadie Powell + * Copyright (C) 2012, 2019 Robby + * Copyright (C) 2012 DjSlash + * Copyright (C) 2012 ChrisTX + * Copyright (C) 2011 jackmcbarn + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2009 Uli Schlachter * Copyright (C) 2008 Thomas Stagner - * Copyright (C) 2003-2007 Craig Edwards - * Copyright (C) 2007 Burlex - * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2008 John Brooks + * Copyright (C) 2007, 2009 Dennis Friis + * Copyright (C) 2006-2009 Robin Burchell + * Copyright (C) 2003-2008 Craig Edwards * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public @@ -61,7 +71,7 @@ enum UserType { USERTYPE_SERVER = 3 }; -/** Holds information relevent to <connect allow> and <connect deny> tags in the config file. +/** Holds information relevant to <connect allow> and <connect deny> tags in the config file. */ struct CoreExport ConnectClass : public refcountbase { @@ -140,6 +150,12 @@ struct CoreExport ConnectClass : public refcountbase */ insp::flat_set ports; + /** If non-empty then the password a user must specify in PASS to be assigned to this class. */ + std::string password; + + /** If non-empty then the hash algorithm that the password field is hashed with. */ + std::string passwordhash; + /** Create a new connect class with no settings. */ ConnectClass(ConfigTag* tag, char type, const std::string& mask); @@ -244,6 +260,15 @@ class CoreExport User : public Extensible */ std::string cachedip; + /** If set then the hostname which is displayed to users. */ + std::string displayhost; + + /** The real hostname of this user. */ + std::string realhost; + + /** The real name of this user. */ + std::string realname; + /** The user's mode list. * Much love to the STL for giving us an easy to use bitset, saving us RAM. * if (modes[modeid]) is set, then the mode is set. @@ -270,11 +295,6 @@ class CoreExport User : public Extensible */ typedef insp::intrusive_list ChanList; - /** Hostname of connection. - * This should be valid as per RFC1035. - */ - std::string host; - /** Time that the object was instantiated (used for TS calculation etc) */ time_t age; @@ -307,15 +327,6 @@ class CoreExport User : public Extensible */ std::string ident; - /** The host displayed to non-opers (used for cloaking etc). - * This usually matches the value of User::host. - */ - std::string dhost; - - /** The users full name (GECOS). - */ - std::string fullname; - /** What snomasks are set on this user. * This functions the same as the above modes. */ @@ -351,7 +362,7 @@ class CoreExport User : public Extensible /** If this is set to true, then all socket operations for the user * are dropped into the bit-bucket. - * This value is set by QuitUser, and is not needed seperately from that call. + * This value is set by QuitUser, and is not needed separately from that call. * Please note that setting this value alone will NOT cause the user to quit. */ unsigned int quitting:1; @@ -364,6 +375,20 @@ class CoreExport User : public Extensible */ const std::string& GetIPString(); + /** Retrieves this user's hostname. + * @param uncloak If true then return the real host; otherwise, the display host. + */ + const std::string& GetHost(bool uncloak) const; + + /** Retrieves this user's displayed hostname. */ + const std::string& GetDisplayedHost() const; + + /** Retrieves this user's real hostname. */ + const std::string& GetRealHost() const; + + /** Retrieves this user's real name. */ + const std::string& GetRealName() const; + /** Get CIDR mask, using default range, for this user */ irc::sockets::cidr_mask GetCIDRMask(); @@ -371,14 +396,14 @@ class CoreExport User : public Extensible /** Sets the client IP for this user * @return true if the conversion was successful */ - virtual bool SetClientIP(const std::string& address, bool recheck_eline = true); + virtual bool SetClientIP(const std::string& address); - virtual void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true); + virtual void SetClientIP(const irc::sockets::sockaddrs& sa); /** Constructor * @throw CoreException if the UID allocated to the user already exists */ - User(const std::string& uid, Server* srv, int objtype); + User(const std::string& uid, Server* srv, UserType objtype); /** Returns the full displayed host of the user * This member function returns the hostname of the user as seen by other users @@ -447,17 +472,16 @@ class CoreExport User : public Extensible * @param command A command (should be all CAPS) * @return True if this user can execute the command */ - virtual bool HasPermission(const std::string &command); + virtual bool HasCommandPermission(const std::string& command); /** Returns true if a user has a given permission. * This is used to check whether or not users may perform certain actions which admins may not wish to give to * all operators, yet are not commands. An example might be oper override, mass messaging (/notice $*), etc. * * @param privstr The priv to chec, e.g. "users/override/topic". These are loaded free-form from the config file. - * @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. * @return True if this user has the permission in question. */ - virtual bool HasPrivPermission(const std::string &privstr, bool noisy = false); + virtual bool HasPrivPermission(const std::string& privstr); /** Returns true or false if a user can set a privileged user or channel mode. * This is done by looking up their oper type from User::oper, then referencing @@ -467,6 +491,12 @@ class CoreExport User : public Extensible */ virtual bool HasModePermission(const ModeHandler* mh) const; + /** Determines whether this user can set the specified snomask. + * @param chr The server notice mask character to look up. + * @return True if the user can set the specified snomask; otherwise, false. + */ + virtual bool HasSnomaskPermission(char chr) const; + /** Creates a usermask with real host. * Takes a buffer to use and fills the given buffer with the hostmask in the format user\@host * @return the usermask in the format user\@host @@ -489,41 +519,10 @@ class CoreExport User : public Extensible */ void UnOper(); - /** Write text to this user, appending CR/LF. Works on local users only. - * @param text A std::string to send to the user - */ - virtual void Write(const std::string &text); - - /** Write text to this user, appending CR/LF. - * Works on local users only. - * @param text The format string for text to send to the user - * @param ... POD-type format arguments - */ - virtual void Write(const char *text, ...) CUSTOM_PRINTF(2, 3); - - /** Write text to this user, appending CR/LF and prepending :server.name - * Works on local users only. - * @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 - * Works on local users only. - * @param text The format string for text to send to the user - * @param ... POD-type format arguments - */ - void WriteServ(const char* text, ...) CUSTOM_PRINTF(2, 3); - - /** Sends a command to this user. - * @param command The command to be sent. - * @param text The message to send. - */ - void WriteCommand(const char* command, const std::string& text); - /** Sends a server notice to this user. * @param text The contents of the message to send. */ - void WriteNotice(const std::string& text) { this->WriteCommand("NOTICE", ":" + text); } + void WriteNotice(const std::string& text); /** Send a NOTICE message from the local server to the user. * @param text Text to send @@ -634,30 +633,11 @@ class CoreExport User : public Extensible WriteNumeric(n); } - /** 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(User *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(User *user, const char* text, ...) CUSTOM_PRINTF(3, 4); - /** Write to all users that can see this user (including this user in the list if include_self is true), appending CR/LF - * @param line A std::string to send to the users + * @param protoev Protocol event to send, may contain any number of messages. * @param include_self Should the message be sent back to the author? */ - void WriteCommonRaw(const std::string &line, bool include_self = true); - - /** 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, ...) CUSTOM_PRINTF(2, 3); + void WriteCommonRaw(ClientProtocol::Event& protoev, bool include_self = true); /** Execute a function once for each local neighbor of this user. By default, the neighbors of a user are the users * who have at least one common channel with the user. Modules are allowed to alter the set of neighbors freely. @@ -675,16 +655,18 @@ class CoreExport User : public Extensible */ bool SharesChannelWith(User *other); - /** Change the displayed host of a user. - * ALWAYS use this function, rather than writing User::dhost directly, - * as this triggers module events allowing the change to be syncronized to - * remote servers. - * @param host The new hostname to set - * @return True if the change succeeded, false if it didn't - * (a module vetoed the change). + /** Change the displayed hostname of this user. + * @param host The new displayed hostname of this user. + * @return True if the hostname was changed successfully; otherwise, false. */ bool ChangeDisplayedHost(const std::string& host); + /** Change the real hostname of this user. + * @param host The new real hostname of this user. + * @param resetdisplay Whether to reset the display host to this value. + */ + void ChangeRealHost(const std::string& host, bool resetdisplay); + /** Change the ident (username) of a user. * ALWAYS use this function, rather than writing User::ident directly, * as this triggers module events allowing the change to be syncronized to @@ -695,13 +677,10 @@ class CoreExport User : public Extensible bool ChangeIdent(const std::string& newident); /** Change a users realname field. - * ALWAYS use this function, rather than writing User::fullname directly, - * as this triggers module events allowing the change to be syncronized to - * remote servers. - * @param gecos The user's new realname + * @param real The user's new real name * @return True if the change succeeded, false if otherwise */ - bool ChangeName(const std::string& gecos); + bool ChangeRealName(const std::string& real); /** Change a user's nick * @param newnick The new nick. If equal to the users uuid, the nick change always succeeds. @@ -718,16 +697,30 @@ class CoreExport User : public Extensible /** Default destructor */ virtual ~User(); - virtual CullResult cull() CXX11_OVERRIDE; + CullResult cull() CXX11_OVERRIDE; + + /** @copydoc Serializable::Deserialize */ + bool Deserialize(Data& data) CXX11_OVERRIDE; + + /** @copydoc Serializable::Deserialize */ + bool Serialize(Serializable::Data& data) CXX11_OVERRIDE; }; class CoreExport UserIOHandler : public StreamSocket { + private: + size_t checked_until; public: LocalUser* const user; - UserIOHandler(LocalUser* me) : user(me) {} - void OnDataReady(); - void OnError(BufferedSocketError error); + UserIOHandler(LocalUser* me) + : StreamSocket(StreamSocket::SS_USER) + , checked_until(0) + , user(me) + { + } + void OnDataReady() CXX11_OVERRIDE; + bool OnSetEndPoint(const irc::sockets::sockaddrs& local, const irc::sockets::sockaddrs& remote) CXX11_OVERRIDE; + void OnError(BufferedSocketError error) CXX11_OVERRIDE; /** Adds to the user's write buffer. * You may add any amount of text up to this users sendq value, if you exceed the @@ -735,18 +728,45 @@ class CoreExport UserIOHandler : public StreamSocket * @param data The data to add to the write buffer */ void AddWriteBuf(const std::string &data); + + /** Swaps the internals of this UserIOHandler with another one. + * @param other A UserIOHandler to swap internals with. + */ + void SwapInternals(UserIOHandler& other); }; typedef unsigned int already_sent_t; class CoreExport LocalUser : public User, public insp::intrusive_list_node { + /** Add a serialized message to the send queue of the user. + * @param serialized Bytes to add. + */ + void Write(const ClientProtocol::SerializedMessage& serialized); + + /** Send a protocol event to the user, consisting of one or more messages. + * @param protoev Event to send, may contain any number of messages. + * @param msglist Message list used temporarily internally to pass to hooks and store messages + * before Write(). + */ + void Send(ClientProtocol::Event& protoev, ClientProtocol::MessageList& msglist); + + /** Message list, can be passed to the two parameter Send(). + */ + static ClientProtocol::MessageList sendmsglist; + public: LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server); + LocalUser(int fd, const std::string& uuid, Serializable::Data& data); + CullResult cull() CXX11_OVERRIDE; UserIOHandler eh; + /** Serializer to use when communicating with the user + */ + ClientProtocol::Serializer* serializer; + /** Stats counter for bytes inbound */ unsigned int bytes_in; @@ -786,11 +806,6 @@ class CoreExport LocalUser : public User, public insp::intrusive_list_nodeGetName(); } FakeUser(const std::string& uid, const std::string& sname, const std::string& sdesc) - : User(uid, new Server(sname, sdesc), USERTYPE_SERVER) + : User(uid, new Server(uid, sname, sdesc), USERTYPE_SERVER) { nick = sname; } - virtual CullResult cull() CXX11_OVERRIDE; - virtual const std::string& GetFullHost() CXX11_OVERRIDE; - virtual const std::string& GetFullRealHost() CXX11_OVERRIDE; + CullResult cull() CXX11_OVERRIDE; + const std::string& GetFullHost() CXX11_OVERRIDE; + const std::string& GetFullRealHost() CXX11_OVERRIDE; }; /* Faster than dynamic_cast */ /** Is a local user */ inline LocalUser* IS_LOCAL(User* u) { - return u->usertype == USERTYPE_LOCAL ? static_cast(u) : NULL; + return (u != NULL && u->usertype == USERTYPE_LOCAL) ? static_cast(u) : NULL; } /** Is a remote user */ inline RemoteUser* IS_REMOTE(User* u) { - return u->usertype == USERTYPE_REMOTE ? static_cast(u) : NULL; + return (u != NULL && u->usertype == USERTYPE_REMOTE) ? static_cast(u) : NULL; } /** Is a server fakeuser */ inline FakeUser* IS_SERVER(User* u) { - return u->usertype == USERTYPE_SERVER ? static_cast(u) : NULL; + return (u != NULL && u->usertype == USERTYPE_SERVER) ? static_cast(u) : NULL; } inline bool User::IsModeSet(const ModeHandler* mh) const { - return (modes[mh->GetId()]); + return ((mh->GetId() != ModeParser::MODEID_MAX) && (modes[mh->GetId()])); } inline bool User::IsModeSet(UserModeReference& moderef) const @@ -941,5 +972,6 @@ inline bool User::IsModeSet(UserModeReference& moderef) const inline void User::SetMode(ModeHandler* mh, bool value) { - modes[mh->GetId()] = value; + if (mh && mh->GetId() != ModeParser::MODEID_MAX) + modes[mh->GetId()] = value; }