/*
* InspIRCd -- Internet Relay Chat Daemon
*
- * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
- * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2019-2020 Matt Schatz <genius3000@g3k.solutions>
+ * Copyright (C) 2019 linuxdaemon <linuxdaemon.irc@gmail.com>
+ * Copyright (C) 2013 Daniel Vassdal <shutter@canternet.org>
+ * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2012-2013, 2016-2020 Sadie Powell <sadie@witchery.services>
+ * Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
+ * Copyright (C) 2012 DjSlash <djslash@djslash.org>
+ * Copyright (C) 2012 ChrisTX <xpipe@hotmail.de>
+ * Copyright (C) 2011 jackmcbarn <jackmcbarn@inspircd.org>
+ * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
+ * Copyright (C) 2009 Uli Schlachter <psychon@inspircd.org>
* Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
- * Copyright (C) 2003-2007 Craig Edwards <craigedwards@brainbox.cc>
- * Copyright (C) 2007 Burlex <???@???>
- * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2008 John Brooks <special@inspircd.org>
+ * Copyright (C) 2007, 2009 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2006-2009 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2003-2008 Craig Edwards <brain@inspircd.org>
*
* 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
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
{
*/
insp::flat_set<int> 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);
*/
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.
*/
/** 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;
*/
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
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
*/
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
*/
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
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.
*/
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;
+
+ /** @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
* @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<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();
+ 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;
*/
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);
-
- void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
+ bool SetClientIP(const std::string& address) CXX11_OVERRIDE;
- void Write(const std::string& text);
- void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
+ void SetClientIP(const irc::sockets::sockaddrs& sa) CXX11_OVERRIDE;
/** 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 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
* @param mh Mode to check
* @return True if the user can set or unset this mode.
*/
- bool HasModePermission(const ModeHandler* mh) const;
+ bool HasModePermission(const ModeHandler* mh) const CXX11_OVERRIDE;
+
+ /** @copydoc User::HasSnomaskPermission */
+ bool HasSnomaskPermission(char chr) 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);
+
+ /** @copydoc Serializable::Deserialize */
+ bool Deserialize(Data& data) CXX11_OVERRIDE;
+
+ /** @copydoc Serializable::Deserialize */
+ bool Serialize(Serializable::Data& data) CXX11_OVERRIDE;
};
class RemoteUser : public User
class CoreExport FakeUser : public User
{
public:
- FakeUser(const std::string& uid, Server* srv) : User(uid, srv, USERTYPE_SERVER)
+ FakeUser(const std::string& uid, Server* srv)
+ : User(uid, srv, USERTYPE_SERVER)
{
nick = srv->GetName();
}
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();
- 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 */
/** Is a local user */
inline LocalUser* IS_LOCAL(User* u)
{
- return u->usertype == USERTYPE_LOCAL ? static_cast<LocalUser*>(u) : NULL;
+ return (u != NULL && u->usertype == USERTYPE_LOCAL) ? static_cast<LocalUser*>(u) : NULL;
}
/** Is a remote user */
inline RemoteUser* IS_REMOTE(User* u)
{
- return u->usertype == USERTYPE_REMOTE ? static_cast<RemoteUser*>(u) : NULL;
+ return (u != NULL && u->usertype == USERTYPE_REMOTE) ? static_cast<RemoteUser*>(u) : NULL;
}
/** Is a server fakeuser */
inline FakeUser* IS_SERVER(User* u)
{
- return u->usertype == USERTYPE_SERVER ? static_cast<FakeUser*>(u) : NULL;
+ return (u != NULL && u->usertype == USERTYPE_SERVER) ? static_cast<FakeUser*>(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
inline void User::SetMode(ModeHandler* mh, bool value)
{
- modes[mh->GetId()] = value;
+ if (mh && mh->GetId() != ModeParser::MODEID_MAX)
+ modes[mh->GetId()] = value;
}
projects / user / henk / code / inspircd.git / blobdiff