#include "socket.h"
#include "inspsocket.h"
-#include "dns.h"
#include "mode.h"
#include "membership.h"
CC_NAMED = 2
};
-/** RFC1459 channel modes
- */
-enum UserModes {
- /** +s: Server notice mask */
- UM_SNOMASK = 's' - 65,
- /** +w: WALLOPS */
- UM_WALLOPS = 'w' - 65,
- /** +i: Invisible */
- UM_INVISIBLE = 'i' - 65,
- /** +o: Operator */
- UM_OPERATOR = 'o' - 65
-};
-
/** Registration state of a user, e.g.
* have they sent USER, NICK, PASS yet?
*/
*/
unsigned long limit;
+ /** If set to true, no user DNS lookups are to be performed
+ */
+ bool resolvehostnames;
+
/** Create a new connect class with no settings.
*/
ConnectClass(ConfigTag* tag, char type, const std::string& mask);
*/
std::string cachedip;
+ /** The user's mode list.
+ * Much love to the STL for giving us an easy to use bitset, saving us RAM.
+ * if (modes[modeletter-65]) is set, then the mode is
+ * set, for example, to work out if mode +s is set, we check the field
+ * User::modes['s'-65] != 0.
+ */
+ std::bitset<64> modes;
+
public:
/** Hostname of connection.
*/
std::string fullname;
- /** The user's mode list.
- * NOT a null terminated string.
- * Also NOT an array.
- * Much love to the STL for giving us an easy to use bitset, saving us RAM.
- * if (modes[modeletter-65]) is set, then the mode is
- * set, for example, to work out if mode +s is set, we check the field
- * User::modes['s'-65] != 0.
- * The following RFC characters o, w, s, i have constants defined via an
- * enum, such as UM_SERVERNOTICE and UM_OPETATOR.
- */
- std::bitset<64> modes;
-
/** What snomasks are set on this user.
* This functions the same as the above modes.
*/
*/
void InvalidateCache();
- /** 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 The cleaned mode sequence which can be output,
- * e.g. in the above example if masks c and e are not
- * valid, this function will return +ab-d
- */
- std::string ProcessNoticeMasks(const char *sm);
-
/** Returns whether this user is currently away or not. If true,
* further information can be found in User::awaymsg and User::awaytime
* @return True if the user is away, false otherwise
*/
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 showparameters The mode string
*/
* @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);
/** 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);
+ void SetMode(ModeHandler* mh, bool value);
+ void SetMode(ModeHandler& mh, bool value) { SetMode(&mh, value); }
/** 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
*/
virtual bool HasModePermission(unsigned char mode, ModeType type);
- /** 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 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
* @param newnick The nickname to change to
* @return True if the nickchange was successful.
*/
- inline bool ForceNickChange(const char* newnick) { return ChangeNick(newnick, true); }
+ bool ForceNickChange(const std::string& newnick) { return ChangeNick(newnick, true); }
/** Oper down.
* This will clear the +o usermode and unset the user's oper type
*/
void WriteServ(const char* text, ...) CUSTOM_PRINTF(2, 3);
+ /** Sends a server notice to this user.
+ * @param text The contents of the message to send.
+ */
+ void WriteNotice(const std::string& text);
+
void WriteNumeric(unsigned int numeric, const char* text, ...) CUSTOM_PRINTF(3, 4);
void WriteNumeric(unsigned int numeric, const std::string &text);
void WriteCommonQuit(const std::string &normal_text, const std::string &oper_text);
/** 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
+ * @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);
+ void SendText(const std::string& linePrefix, std::stringstream& textStream);
/** Write to the user, routing the line if the user is remote.
*/
*/
bool SharesChannelWith(User *other);
- /** Send fake quit/join messages for host or ident cycle.
- * Run this after the item in question has changed.
- * You should not need to use this function, call ChangeDisplayedHost instead
- *
- * @param quitline The entire QUIT line, including the source using the old value
- */
- void DoHostCycle(const std::string &quitline);
-
/** 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. This will also emulate a QUIT and rejoin (where configured)
- * before setting their host field.
+ * 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).
*/
- bool ChangeDisplayedHost(const char* host);
+ bool ChangeDisplayedHost(const std::string& host);
/** Change the ident (username) of a user.
* ALWAYS use this function, rather than writing User::ident directly,
- * as this correctly causes the user to seem to quit (where configured)
- * before setting their ident field.
+ * as this triggers module events allowing the change to be syncronized to
+ * remote servers.
* @param newident The new ident to set
* @return True if the change succeeded, false if it didn't
*/
- bool ChangeIdent(const char* newident);
+ bool ChangeIdent(const std::string& newident);
/** Change a users realname field.
* ALWAYS use this function, rather than writing User::fullname directly,
* @param gecos The user's new realname
* @return True if the change succeeded, false if otherwise
*/
- bool ChangeName(const char* gecos);
+ bool ChangeName(const std::string& gecos);
/** Change a user's nick
* @param newnick The new nick
*/
void PurgeEmptyChannels();
- /** Get the connect class which this user belongs to. NULL for remote users.
- * @return A pointer to this user's connect class.
- */
- virtual ConnectClass* GetClass();
-
/** Default destructor
*/
virtual ~User();
*/
reference<ConnectClass> MyClass;
- ConnectClass* GetClass();
+ /** Get the connect class which this user belongs to.
+ * @return A pointer to this user's connect class.
+ */
+ ConnectClass* GetClass() const { return MyClass; }
/** Call this method to find the matching \<connect> for a user, and to check them against it.
*/
- void CheckClass();
+ void CheckClass(bool clone_count = true);
/** Server address and port that this user is connected to.
*/
*/
unsigned int quitting_sendq:1;
- /** True when DNS lookups are completed.
- * The UserResolver classes res_forward and res_reverse will
- * set this value once they complete.
- */
- unsigned int dns_done:1;
-
/** has the user responded to their previous ping?
*/
unsigned int lastping:1;
static already_sent_t already_sent_id;
already_sent_t already_sent;
- /** Stored reverse lookup from res_forward. Should not be used after resolution.
- */
- std::string stored_host;
-
- /** Starts a DNS lookup of the user's IP.
- * This will cause two UserResolver classes to be instantiated.
- * When complete, these objects set User::dns_done to true.
- */
- void StartDNSLookup();
-
/** 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)
* Returns true if the user matched a ban, false else.
InviteList& GetInviteList();
/** Returns true if a user is invited to a channel.
- * @param channel A channel name to look up
+ * @param chan A channel to look up
* @return True if the user is invited to the given channel
*/
- bool IsInvited(const irc::string &channel);
-
- /** Adds a channel to a users invite list (invites them to a channel)
- * @param channel A channel name to add
- * @param timeout When the invite should expire (0 == never)
- */
- void InviteTo(const irc::string &channel, time_t timeout);
+ bool IsInvited(Channel* chan) { return (Invitation::Find(chan, this) != NULL); }
/** 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
+ * @param chan The channel to remove the invite to
+ * @return True if the user was invited to the channel and the invite was erased, false if the user wasn't invited
*/
- void RemoveInvite(const irc::string &channel);
+ bool RemoveInvite(Channel* chan);
void RemoveExpiredInvites();
return u->usertype == USERTYPE_SERVER ? static_cast<FakeUser*>(u) : NULL;
}
-/** Derived from Resolver, and performs user forward/reverse lookups.
- */
-class CoreExport UserResolver : public Resolver
+inline bool User::IsModeSet(ModeHandler* mh)
{
- private:
- /** UUID we are looking up */
- std::string uuid;
- /** True if the lookup is forward, false if is a reverse lookup
- */
- bool fwd;
- public:
- /** Create a resolver.
- * @param user The user to begin lookup on
- * @param to_resolve The IP or host to resolve
- * @param qt The query type
- * @param cache Modified by the constructor if the result was cached
- */
- UserResolver(LocalUser* user, std::string to_resolve, QueryType qt, bool &cache);
+ char m = mh->GetModeChar();
+ return (modes[m-65]);
+}
- /** Called on successful lookup
- * @param result Result string
- * @param ttl Time to live for result
- * @param cached True if the result was found in the cache
- */
- void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached);
+inline bool User::IsModeSet(UserModeReference& moderef)
+{
+ if (!moderef)
+ return false;
+ return IsModeSet(*moderef);
+}
- /** Called on failed lookup
- * @param e Error code
- * @param errormessage Error message string
- */
- void OnError(ResolverError e, const std::string &errormessage);
-};
+inline void User::SetMode(ModeHandler* mh, bool value)
+{
+ char m = mh->GetModeChar();
+ modes[m-65] = value;
+}
projects / user / henk / code / inspircd.git / blobdiff