*/
bool resolvehostnames;
+ /**
+ * If non-empty the server ports which this user has to be using
+ */
+ insp::flat_set<int> ports;
+
/** Create a new connect class with no settings.
*/
ConnectClass(ConfigTag* tag, char type, const std::string& mask);
*/
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.
*/
typedef insp::intrusive_list<Membership> 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;
*/
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.
*/
unsigned int quitting:1;
/** What type of user is this? */
- const unsigned int usertype:2;
+ const UserType usertype:2;
/** Get client IP string from sockaddr, using static internal buffer
* @return The IP string
*/
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();
/** Sets the client IP for this user
* @return true if the conversion was successful
*/
- virtual bool SetClientIP(const char* sip, 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
*/
bool IsNoticeMaskSet(unsigned char sm);
- /** Create a displayable mode string for this users umodes
- * @param showparameters The mode string
+ /** Get the mode letters of modes set on the user as a string.
+ * @param includeparams True to get the parameters of the modes as well. Defaults to false.
+ * @return Mode letters of modes set on the user and optionally the parameters of those modes, if any.
+ * The returned string always begins with a '+' character. If the user has no modes set, "+" is returned.
*/
- const char* FormatModes(bool showparameters = false);
+ std::string GetModeLetters(bool includeparams = false) const;
/** 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);
- bool IsModeSet(ModeHandler* mh);
- bool IsModeSet(ModeHandler& mh) { return IsModeSet(&mh); }
- bool IsModeSet(UserModeReference& moderef);
+ bool IsModeSet(unsigned char m) const;
+ bool IsModeSet(const ModeHandler* mh) const;
+ bool IsModeSet(const ModeHandler& mh) const { return IsModeSet(&mh); }
+ bool IsModeSet(UserModeReference& moderef) const;
/** Set a specific usermode to on or off
- * @param m The user mode
+ * @param mh The user mode
* @param value On or off setting of the mode
*/
void SetMode(ModeHandler* mh, bool value);
* @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
* this to their oper classes, and checking the modes they can set.
- * @param mode The mode the check
- * @param type ModeType (MODETYPE_CHANNEL or MODETYPE_USER).
+ * @param mh Mode to check
* @return True if the user can set or unset this mode.
*/
- virtual bool HasModePermission(unsigned char mode, ModeType type);
+ virtual bool HasModePermission(const ModeHandler* mh) 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
*/
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
+ */
+ virtual void WriteRemoteNotice(const std::string& text);
- void WriteRemoteNumeric(const Numeric::Numeric& numeric);
+ virtual void WriteRemoteNumeric(const Numeric::Numeric& numeric);
template <typename T1>
void WriteRemoteNumeric(unsigned int numeric, T1 p1)
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.
*/
void ForEachNeighbor(ForEachNeighborHandler& handler, bool include_self = true);
- /** Dump text to a user target, splitting it appropriately to fit
- * @param linePrefix text to prefix each complete line with
- * @param textStream the text to send to the user
- */
- void SendText(const std::string& linePrefix, std::stringstream& textStream);
-
- /** Write to the user, routing the line if the user is remote.
- */
- virtual void SendText(const std::string& line) = 0;
-
- /** Write to the user, routing the line if the user is remote.
- */
- void SendText(const char* text, ...) CUSTOM_PRINTF(2, 3);
-
/** Return true if the user shares at least one channel with another user
* @param other The other user to compare the channel list against
* @return True if the given user shares at least one channel with this user
*/
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
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.
+ * @param newts The time at which this nick change happened.
* @return True if the change succeeded
*/
bool ChangeNick(const std::string& newnick, time_t newts = 0);
/** Default destructor
*/
virtual ~User();
- virtual CullResult cull();
+ CullResult cull() 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
class CoreExport LocalUser : public User, public insp::intrusive_list_node<LocalUser>
{
+ /** 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);
- CullResult cull();
+ 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;
*/
irc::sockets::sockaddrs server_sa;
- /**
- * @return The port number of this user.
- */
- int GetServerPort();
-
/** Recursion fix: user is out of SendQ and will be quit as soon as possible.
* This can't be handled normally because QuitUser itself calls Write on other
* users, which could trigger their SendQ to overrun.
*/
unsigned int lastping:1;
- /** This is true if the user matched an exception (E:Line). It is used to save time on ban checks.
+ /** This is true if the user matched an exception (E-line). It is used to save time on ban checks.
*/
unsigned int exempt:1;
- /** Used by PING checking code
- */
- time_t nping;
+ /** The time at which this user should be pinged next. */
+ time_t nextping;
/** Time that the connection last sent a message, used to calculate idle time
*/
already_sent_t already_sent;
- /** Check if the user matches a G or K line, and disconnect them if they do.
- * @param doZline True if ZLines should be checked (if IP has changed since initial connect)
+ /** Check if the user matches a G- or K-line, and disconnect them if they do.
+ * @param doZline True if Z-lines should be checked (if IP has changed since initial connect)
* Returns true if the user matched a ban, false else.
*/
bool CheckLines(bool doZline = false);
/** Use this method to fully connect a user.
- * This will send the message of the day, check G/K/E lines, etc.
+ * This will send the message of the day, check G/K/E-lines, etc.
*/
void FullConnect();
*/
void SetClass(const std::string &explicit_name = "");
- bool SetClientIP(const char* sip, bool recheck_eline = true);
+ bool SetClientIP(const std::string& address) CXX11_OVERRIDE;
- void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
+ void SetClientIP(const irc::sockets::sockaddrs& sa) CXX11_OVERRIDE;
- void SendText(const std::string& line);
- void Write(const std::string& text);
- void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
+ /** Send a NOTICE message from the local server to the user.
+ * The message will be sent even if the user is connected to a remote server.
+ * @param text Text to send
+ */
+ void WriteRemoteNotice(const std::string& text) CXX11_OVERRIDE;
/** Returns true or false for if a user can execute a privilaged oper command.
* This is done by looking up their oper type from User::oper, then referencing
* @param command A command (should be all CAPS)
* @return True if this user can execute the command
*/
- bool HasPermission(const std::string &command);
+ bool HasCommandPermission(const std::string& command) CXX11_OVERRIDE;
/** 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.
*/
- bool HasPrivPermission(const std::string &privstr, bool noisy = false);
+ bool HasPrivPermission(const std::string& privstr) CXX11_OVERRIDE;
/** 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
* this to their oper classes, and checking the modes they can set.
- * @param mode The mode the check
- * @param type ModeType (MODETYPE_CHANNEL or MODETYPE_USER).
+ * @param mh Mode to check
* @return True if the user can set or unset this mode.
*/
- bool HasModePermission(unsigned char mode, ModeType type);
+ bool HasModePermission(const ModeHandler* mh) const CXX11_OVERRIDE;
+
+ /** Change nick to uuid, unset REG_NICK and send a nickname overruled numeric.
+ * This is called when another user (either local or remote) needs the nick of this user and this user
+ * isn't registered.
+ */
+ void OverruleNick();
+
+ /** Send a protocol event to the user, consisting of one or more messages.
+ * @param protoev Event to send, may contain any number of messages.
+ */
+ void Send(ClientProtocol::Event& protoev);
+
+ /** Send a single message to the user.
+ * @param protoevprov Protocol event provider.
+ * @param msg Message to send.
+ */
+ void Send(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg);
};
-class CoreExport RemoteUser : public User
+class RemoteUser : public User
{
public:
RemoteUser(const std::string& uid, Server* srv) : User(uid, srv, USERTYPE_REMOTE)
{
}
- virtual void SendText(const std::string& line);
};
class CoreExport FakeUser : public User
nick = sname;
}
- virtual CullResult cull();
- virtual void SendText(const std::string& line);
- virtual const std::string& GetFullHost();
- virtual const std::string& GetFullRealHost();
+ CullResult cull() CXX11_OVERRIDE;
+ const std::string& GetFullHost() CXX11_OVERRIDE;
+ const std::string& GetFullRealHost() CXX11_OVERRIDE;
};
/* Faster than dynamic_cast */
return u->usertype == USERTYPE_SERVER ? static_cast<FakeUser*>(u) : NULL;
}
-inline bool User::IsModeSet(ModeHandler* mh)
+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)
+inline bool User::IsModeSet(UserModeReference& moderef) const
{
if (!moderef)
return false;
inline void User::SetMode(ModeHandler* mh, bool value)
{
- modes[mh->GetId()] = value;
+ if (mh && mh->GetId() != ModeParser::MODEID_MAX)
+ modes[mh->GetId()] = value;
}