Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

users.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef __USERS_H__
#define __USERS_H__

#include "socket.h"
#include "connection.h"
#include "dns.h"
#include "mode.h"

enum ChanStatus {
        STATUS_OP     = 4,
        STATUS_HOP    = 2,
        STATUS_VOICE  = 1,
        STATUS_NORMAL = 0
};

enum ClassTypes {
        CC_ALLOW = 0,
        CC_DENY  = 1
};

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 */
};

/* Required forward declaration */
class Channel;
class UserResolver;

class CoreExport ConnectClass : public classbase
{
 private:
        char type;
        std::string name;
        unsigned int registration_timeout;
        unsigned int flood;
        std::string host;
        unsigned int pingtime;
        std::string pass;

        std::string hash;

        unsigned int threshold;

        unsigned long sendqmax;

        unsigned long recvqmax;

        unsigned long maxlocal;

        unsigned long maxglobal;

        unsigned int maxchans;

        int port;

public:

        ConnectClass(const ConnectClass* source) : classbase(), type(source->type), name(source->name),
                registration_timeout(source->registration_timeout), flood(source->flood), host(source->host),
                pingtime(source->pingtime), pass(source->pass), hash(source->hash), threshold(source->threshold), sendqmax(source->sendqmax),
                recvqmax(source->recvqmax), maxlocal(source->maxlocal), maxglobal(source->maxglobal), maxchans(source->maxchans),
                port(source->port), RefCount(0), disabled(false), limit(source->limit)
        {
        }

        ConnectClass() : type(CC_DENY), name("unnamed"), registration_timeout(0), flood(0), host(""), pingtime(0), pass(""), hash(""),
                        threshold(0), sendqmax(0), recvqmax(0), maxlocal(0), maxglobal(0), RefCount(0), disabled(false), limit(0)
        {
        }

        ConnectClass(const std::string &thename, unsigned int timeout, unsigned int fld, const std::string &hst, unsigned int ping,
                        const std::string &pas, const std::string &hsh, unsigned int thres, unsigned long sendq, unsigned long recvq,
                        unsigned long maxl, unsigned long maxg, unsigned int maxc, int p = 0) :
                        type(CC_ALLOW), name(thename), registration_timeout(timeout), flood(fld), host(hst), pingtime(ping), pass(pas), hash(hsh),
                        threshold(thres), sendqmax(sendq), recvqmax(recvq), maxlocal(maxl), maxglobal(maxg), maxchans(maxc), port(p), RefCount(0), disabled(false), limit(0) { }

        ConnectClass(const std::string &thename, const std::string &hst) : type(CC_DENY), name(thename), registration_timeout(0),
                        flood(0), host(hst), pingtime(0), pass(""), hash(""), threshold(0), sendqmax(0), recvqmax(0), maxlocal(0), maxglobal(0), maxchans(0), port(0), RefCount(0), disabled(false), limit(0)
        {
        }

        /* Create a new connect class based on another class
         * @param thename The name of the connect class
         * @param source Another connect class to inherit all but the name from
         */
        ConnectClass(const std::string &thename, const ConnectClass* source) : type(source->type), name(thename),
                                registration_timeout(source->registration_timeout), flood(source->flood), host(source->host),
                                pingtime(source->pingtime), pass(source->pass), hash(source->hash), threshold(source->threshold), sendqmax(source->sendqmax),
                                recvqmax(source->recvqmax), maxlocal(source->maxlocal), maxglobal(source->maxglobal), maxchans(source->maxchans),
                                port(source->port), RefCount(0), disabled(false), limit(source->limit)
        {
        }

        void SetDisabled(bool t)
        {
                this->disabled = t;
        }

        bool GetDisabled()
        {
                return this->disabled;
        }

        /* Update an existing entry with new values
         */
        void Update(unsigned int timeout, unsigned int fld, const std::string &hst, unsigned int ping,
                                const std::string &pas, unsigned int thres, unsigned long sendq, unsigned long recvq,
                                unsigned long maxl, unsigned long maxg, unsigned int maxc, int p, unsigned long llimit)
        {
                if (timeout)
                        registration_timeout = timeout;
                if (fld)
                        flood = fld;
                if (!hst.empty())
                        host = hst;
                if (ping)
                        pingtime = ping;
                if (!pas.empty())
                        pass = pas;
                if (thres)
                        threshold = thres;
                if (sendq)
                        sendqmax = sendq;
                if (recvq)
                        recvqmax = recvq;
                if (maxl)
                        maxlocal = maxl;
                if (maxg)
                        maxglobal = maxg;
                if (maxc)
                        maxchans = maxc;
                if (p)
                        port = p;

                this->limit = llimit;
        }

        void Update(const std::string &n, const std::string &hst)
        {
                name = n;
                host = hst;
        }

        unsigned long RefCount;

        bool disabled;

        unsigned long limit;

        size_t GetMaxChans()
        {
                return maxchans;
        }

        char GetType()
        {
                return (type == CC_ALLOW ? CC_ALLOW : CC_DENY);
        }

        std::string& GetName()
        {
                return name;
        }

        time_t GetRegTimeout()
        {
                return (registration_timeout ? registration_timeout : 90);
        }

        unsigned int GetFlood()
        {
                return (threshold ? flood : 999);
        }

        const std::string& GetHost()
        {
                return host;
        }

        int GetPort()
        {
                return port;
        }

        void SetPort(int p)
        {
                port = p;
        }

        unsigned int GetPingTime()
        {
                return (pingtime ? pingtime : 120);
        }

        const std::string& GetPass()
        {
                return pass;
        }

        const std::string& GetHash()
        {
                return hash;
        }

        unsigned int GetThreshold()
        {
                return (threshold ? threshold : 1);
        }

        unsigned long GetSendqMax()
        {
                return (sendqmax ? sendqmax : 262114);
        }

        unsigned long GetRecvqMax()
        {
                return (recvqmax ? recvqmax : 4096);
        }

        unsigned long GetMaxLocal()
        {
                return maxlocal;
        }

        unsigned long GetMaxGlobal()
        {
                return maxglobal;
        }
};

typedef std::vector< std::pair<irc::string, time_t> > InvitedList;

typedef std::vector<ConnectClass*> ClassVector;

typedef std::map<Channel*, char> UserChanList;

typedef UserChanList::iterator UCListIter;

/* Required forward declaration
 */
class User;

class CoreExport VisData
{
 public:
        VisData();
        virtual ~VisData();
        virtual bool VisibleTo(User* user);
};

class CoreExport User : public connection
{
 private:
        InspIRCd* ServerInstance;

        InvitedList invites;

        std::string cached_fullhost;

        std::string cached_hostip;

        std::string cached_makehost;

        std::string cached_fullrealhost;

        std::string cachedip;

        void DecrementModes();

        std::map<std::string, bool>* AllowedOperCommands;

        bool* AllowedUserModes;

        bool* AllowedChanModes;

 public:
        Module* io;

        ConnectClass *MyClass;

        VisData* Visibility;

        std::string stored_host;

        void StartDNSLookup();

        std::string nick;
        
        std::string uuid;
        
        std::string ident;
        
        std::string dhost;
        
        std::string fullname;
        
        std::bitset<64> modes;

        std::bitset<64> snomasks;

        UserChanList chans;

        const char* server;

        std::string awaymsg;
        
        time_t awaytime;

        std::string oper;
        
        bool dns_done;

        std::string password;
        
        std::string recvq;

        std::string sendq;

        std::string quitmsg;

        std::string operquitmsg;

        bool quietquit;

        unsigned int lines_in;

        time_t reset_due;

        bool quitting;

        sockaddr* ip;

        void SetSockAddr(int protocol_family, const char* ip, int port);

        int GetPort();

        int GetProtocolFamily();

        const char* GetIPString(bool translate4in6 = true);

        const char *GetCIDRMask(int range);

        bool exempt;

        int Penalty;

        bool OverPenalty;

        bool ExemptFromPenalty;

        User(InspIRCd* Instance, const std::string &uid = "");

        bool CheckLines();

        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 IsInvited(const irc::string &channel);

        virtual void InviteTo(const irc::string &channel, time_t timeout);

        virtual void RemoveInvite(const irc::string &channel);

        bool HasPermission(const std::string &command);

        bool HasModePermission(unsigned char mode, ModeType type);

        int ReadData(void* buffer, size_t size);

        bool AddBuffer(const std::string &a);

        bool BufferIsReady();

        void ClearBuffer();

        std::string GetBuffer();

        void AddWriteBuf(const std::string &data);

        void FlushWriteBuf();

        InvitedList* GetInviteList();

        char* MakeWildHost();

        const std::string& MakeHost();

        const std::string& MakeHostIP();

        void CloseSocket();

        void AddToWhoWas();

        void Oper(const std::string &opertype, const std::string &opername);

        void CheckClass();

        void FullConnect();

        User* UpdateNickHash(const char* New);

        bool ForceNickChange(const char* newnick);

        void UnOper();

        void Write(std::string text);

        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 WriteCommon(const std::string &text);

        void WriteCommon(const char* text, ...) CUSTOM_PRINTF(2, 3);

        void WriteCommonExcept(const char* text, ...) CUSTOM_PRINTF(2, 3);

        void WriteCommonExcept(const std::string &text);

        void WriteCommonQuit(const std::string &normal_text, const std::string &oper_text);

        void WriteWallOps(const char* text, ...) CUSTOM_PRINTF(2, 3);

        void WriteWallOps(const std::string &text);

        bool SharesChannelWith(User *other);

        bool ChangeDisplayedHost(const char* host);

        bool ChangeIdent(const char* newident);

        bool ChangeName(const char* gecos);

        void SendAll(const char* command, const char* text, ...) CUSTOM_PRINTF(3, 4);

        std::string ChannelList(User* source);

        void SplitChanList(User* dest, const std::string &cl);

        void PurgeEmptyChannels();

        ConnectClass *GetClass();

        ConnectClass *SetClass(const std::string &explicit_name = "");

        void ShowMOTD();

        void ShowRULES();

        void SetOperQuit(const std::string &oquit);

        const std::string& GetOperQuit();

        void IncreasePenalty(int increase);

        void DecreasePenalty(int decrease);

        void HandleEvent(EventType et, int errornum = 0);

        virtual ~User();
};

class CoreExport UserResolver : public Resolver
{
 private:
        User* bound_user;
        int bound_fd;
        bool fwd;
 public:
        UserResolver(InspIRCd* Instance, User* user, std::string to_resolve, QueryType qt, bool &cache);

        void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum = 0);

        void OnError(ResolverError e, const std::string &errormessage);
};

/* Configuration callbacks */
//class ServerConfig;

#endif