users.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2008 Thomas Stagner <[email protected]>
 *   Copyright (C) 2003-2007 Craig Edwards <[email protected]>
 *   Copyright (C) 2007 Burlex <[email protected]???>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *
 * 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
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef USERS_H
#define USERS_H
 
#include "socket.h"
#include "inspsocket.h"
#include "dns.h"
#include "mode.h"
#include "membership.h"
 
enum ClassTypes {
        CC_ALLOW = 0,
        CC_DENY  = 1,
        CC_NAMED = 2
};
 
enum UserModes {
        UM_SNOMASK = 's' - 65,
        UM_WALLOPS = 'w' - 65,
        UM_INVISIBLE = 'i' - 65,
        UM_OPERATOR = 'o' - 65
};
 
enum RegistrationState {
 
#ifndef _WIN32   // Burlex: This is already defined in win32, luckily it is still 0.
        REG_NONE = 0,           /* Has sent nothing */
#endif
 
        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 */
};
 
enum UserType {
        USERTYPE_LOCAL = 1,
        USERTYPE_REMOTE = 2,
        USERTYPE_SERVER = 3
};
 
struct CoreExport ConnectClass : public refcountbase
{
        reference<ConfigTag> config;
        char type;
 
        bool fakelag;
 
        std::string name;
 
        unsigned int registration_timeout;
 
        std::string host;
 
        unsigned int pingtime;
 
        unsigned long softsendqmax;
 
        unsigned long hardsendqmax;
 
        unsigned long recvqmax;
 
        unsigned int penaltythreshold;
 
        unsigned int commandrate;
 
        unsigned long maxlocal;
 
        unsigned long maxglobal;
 
        bool maxconnwarn;
 
        unsigned int maxchans;
 
        unsigned long limit;
 
        ConnectClass(ConfigTag* tag, char type, const std::string& mask);
        ConnectClass(ConfigTag* tag, char type, const std::string& mask, const ConnectClass& parent);
 
        void Update(const ConnectClass* newSettings);
 
        const std::string& GetName() { return name; }
        const std::string& GetHost() { return host; }
 
        time_t GetRegTimeout()
        {
                return (registration_timeout ? registration_timeout : 90);
        }
 
        unsigned int GetPingTime()
        {
                return (pingtime ? pingtime : 120);
        }
 
        unsigned long GetSendqSoftMax()
        {
                return (softsendqmax ? softsendqmax : 4096);
        }
 
        unsigned long GetSendqHardMax()
        {
                return (hardsendqmax ? hardsendqmax : 0x100000);
        }
 
        unsigned long GetRecvqMax()
        {
                return (recvqmax ? recvqmax : 4096);
        }
 
        unsigned int GetPenaltyThreshold()
        {
                return penaltythreshold ? penaltythreshold : (fakelag ? 10 : 20);
        }
 
        unsigned int GetCommandRate()
        {
                return commandrate ? commandrate : 1000;
        }
 
        unsigned long GetMaxLocal()
        {
                return maxlocal;
        }
 
        unsigned long GetMaxGlobal()
        {
                return maxglobal;
        }
};
 
class CoreExport User : public Extensible
{
 private:
        std::string cached_fullhost;
 
        std::string cached_hostip;
 
        std::string cached_makehost;
 
        std::string cached_fullrealhost;
 
        std::string cachedip;
 
 public:
 
        std::string host;
 
        time_t age;
 
        time_t signon;
 
        time_t idle_lastmsg;
 
        irc::sockets::sockaddrs client_sa;
 
        std::string nick;
 
        const std::string uuid;
 
        std::string ident;
 
        std::string dhost;
 
        std::string fullname;
 
        std::bitset<64> modes;
 
        std::bitset<64> snomasks;
 
        UserChanList chans;
 
        const std::string server;
 
        std::string awaymsg;
 
        time_t awaytime;
 
        reference<OperInfo> oper;
 
        unsigned int registered:3;
 
        unsigned int dns_done:1;
 
        unsigned int quietquit:1;
 
        unsigned int quitting:1;
 
        unsigned int quitting_sendq:1;
 
        unsigned int exempt:1;
 
        unsigned int lastping:1;
 
        const unsigned int usertype:2;
 
        const char* GetIPString();
 
        irc::sockets::cidr_mask GetCIDRMask();
 
        virtual bool SetClientIP(const char* sip, bool recheck_eline = true);
 
        virtual void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
 
        User(const std::string &uid, const std::string& srv, int objtype);
 
        bool CheckLines(bool doZline = false);
 
        virtual const std::string& GetFullHost();
 
        virtual const std::string& GetFullRealHost();
 
        void InvalidateCache();
 
        const char* FormatNoticeMasks();
 
        std::string ProcessNoticeMasks(const char *sm);
 
        bool IsNoticeMaskSet(unsigned char sm);
 
        void SetNoticeMask(unsigned char sm, bool value);
 
        const char* FormatModes(bool showparameters = false);
 
        bool IsModeSet(unsigned char m);
 
        void SetMode(unsigned char m, bool value);
 
        virtual bool HasPermission(const std::string &command);
 
        virtual bool HasPrivPermission(const std::string &privstr, bool noisy = false);
 
        virtual bool HasModePermission(unsigned char mode, ModeType type);
 
        char* MakeWildHost();
 
        const std::string& MakeHost();
 
        const std::string& MakeHostIP();
 
        void AddToWhoWas();
 
        void Oper(OperInfo* info);
 
        inline bool ForceNickChange(const char* newnick) { return ChangeNick(newnick, true); }
 
        void UnOper();
 
        virtual void Write(const std::string &text);
 
        virtual void Write(const char *text, ...) CUSTOM_PRINTF(2, 3);
 
        void WriteServ(const std::string& text);
 
        void WriteServ(const char* text, ...) CUSTOM_PRINTF(2, 3);
 
        void WriteNumeric(unsigned int numeric, const char* text, ...) CUSTOM_PRINTF(3, 4);
 
        void WriteNumeric(unsigned int numeric, const std::string &text);
 
        void WriteFrom(User *user, const std::string &text);
 
        void WriteFrom(User *user, const char* text, ...) CUSTOM_PRINTF(3, 4);
 
        void WriteTo(User *dest, const std::string &data);
 
        void WriteTo(User *dest, const char *data, ...) CUSTOM_PRINTF(3, 4);
 
        void WriteCommonRaw(const std::string &line, bool include_self = true);
 
        void WriteCommon(const char* text, ...) CUSTOM_PRINTF(2, 3);
 
        void WriteCommonExcept(const char* text, ...) CUSTOM_PRINTF(2, 3);
 
        void WriteCommonQuit(const std::string &normal_text, const std::string &oper_text);
 
        void SendText(const std::string &LinePrefix, std::stringstream &TextStream);
 
        virtual void SendText(const std::string& line) = 0;
 
        void SendText(const char* text, ...) CUSTOM_PRINTF(2, 3);
 
        bool SharesChannelWith(User *other);
 
        void DoHostCycle(const std::string &quitline);
 
        bool ChangeDisplayedHost(const char* host);
 
        bool ChangeIdent(const char* newident);
 
        bool ChangeName(const char* gecos);
 
        bool ChangeNick(const std::string& newnick, bool force = false);
 
        void SendAll(const char* command, const char* text, ...) CUSTOM_PRINTF(3, 4);
 
        std::string ChannelList(User* source, bool spy);
 
        void SplitChanList(User* dest, const std::string &cl);
 
        void PurgeEmptyChannels();
 
        virtual ConnectClass* GetClass();
 
        virtual ~User();
        virtual CullResult cull();
};
 
class CoreExport UserIOHandler : public StreamSocket
{
 public:
        LocalUser* const user;
        UserIOHandler(LocalUser* me) : user(me) {}
        void OnDataReady();
        void OnError(BufferedSocketError error);
 
        void AddWriteBuf(const std::string &data);
};
 
typedef unsigned int already_sent_t;
 
class CoreExport LocalUser : public User, public InviteBase
{
 public:
        LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
        CullResult cull();
 
        UserIOHandler eh;
 
        LocalUserList::iterator localuseriter;
 
        unsigned int bytes_in;
 
        unsigned int bytes_out;
 
        unsigned int cmds_in;
 
        unsigned int cmds_out;
 
        std::string password;
 
        reference<ConnectClass> MyClass;
 
        ConnectClass* GetClass();
 
        void CheckClass();
 
        irc::sockets::sockaddrs server_sa;
 
        int GetServerPort();
 
        time_t nping;
 
        unsigned int CommandFloodPenalty;
 
        static already_sent_t already_sent_id;
        already_sent_t already_sent;
 
        std::string stored_host;
 
        void StartDNSLookup();
 
        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);
 
        void SendText(const std::string& line);
        void Write(const std::string& text);
        void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
 
        InviteList& GetInviteList();
 
        bool IsInvited(const irc::string &channel);
 
        void InviteTo(const irc::string &channel, time_t timeout);
 
        void RemoveInvite(const irc::string &channel);
 
        void RemoveExpiredInvites();
 
        bool HasPermission(const std::string &command);
 
        bool HasPrivPermission(const std::string &privstr, bool noisy = false);
 
        bool HasModePermission(unsigned char mode, ModeType type);
};
 
class CoreExport RemoteUser : public User
{
 public:
        RemoteUser(const std::string& uid, const std::string& srv) : User(uid, srv, USERTYPE_REMOTE)
        {
        }
        virtual void SendText(const std::string& line);
};
 
class CoreExport FakeUser : public User
{
 public:
        FakeUser(const std::string &uid, const std::string& srv) : User(uid, srv, USERTYPE_SERVER)
        {
                nick = srv;
        }
 
        virtual CullResult cull();
        virtual void SendText(const std::string& line);
        virtual const std::string& GetFullHost();
        virtual const std::string& GetFullRealHost();
};
 
/* Faster than dynamic_cast */
inline LocalUser* IS_LOCAL(User* u)
{
        return u->usertype == USERTYPE_LOCAL ? static_cast<LocalUser*>(u) : NULL;
}
inline RemoteUser* IS_REMOTE(User* u)
{
        return u->usertype == USERTYPE_REMOTE ? static_cast<RemoteUser*>(u) : NULL;
}
inline FakeUser* IS_SERVER(User* u)
{
        return u->usertype == USERTYPE_SERVER ? static_cast<FakeUser*>(u) : NULL;
}
#define IS_OPER(x) (x->oper)
 
#define IS_AWAY(x) (!x->awaymsg.empty())
 
class CoreExport UserResolver : public Resolver
{
 private:
        std::string uuid;
        bool fwd;
 public:
        UserResolver(LocalUser* user, std::string to_resolve, QueryType qt, bool &cache);
 
        void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached);
 
        void OnError(ResolverError e, const std::string &errormessage);
};
 
#endif