users.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2019 linuxdaemon <[email protected]>
 *   Copyright (C) 2019 Matt Schatz <[email protected]>
 *   Copyright (C) 2013 Daniel Vassdal <[email protected]>
 *   Copyright (C) 2012-2016, 2018 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2013, 2016-2019 Sadie Powell <[email protected]>
 *   Copyright (C) 2012, 2018-2019 Robby <[email protected]>
 *   Copyright (C) 2012 DjSlash <[email protected]>
 *   Copyright (C) 2012 ChrisTX <[email protected]>
 *   Copyright (C) 2009-2010 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2009 Uli Schlachter <[email protected]>
 *   Copyright (C) 2008 Thomas Stagner <[email protected]>
 *   Copyright (C) 2008 John Brooks <[email protected]>
 *   Copyright (C) 2007-2009 Robin Burchell <[email protected]>
 *   Copyright (C) 2007, 2009 Dennis Friis <[email protected]>
 *   Copyright (C) 2006-2008 Craig Edwards <[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/>.
 */
 
 
#pragma once
 
#include "socket.h"
#include "inspsocket.h"
#include "mode.h"
#include "membership.h"
 
enum ClassTypes {
        CC_ALLOW = 0,
        CC_DENY  = 1,
        CC_NAMED = 2
};
 
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;
 
        bool resolvehostnames;
 
        insp::flat_set<int> ports;
 
        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;
 
        std::string displayhost;
 
        std::string realhost;
 
        std::string realname;
 
        std::bitset<ModeParser::MODEID_MAX> modes;
 
 public:
        class ForEachNeighborHandler
        {
         public:
                virtual void Execute(LocalUser* user) = 0;
        };
 
        typedef insp::intrusive_list<Membership> ChanList;
 
        time_t age;
 
        time_t signon;
 
        irc::sockets::sockaddrs client_sa;
 
        std::string nick;
 
        const std::string uuid;
 
        std::string ident;
 
        std::bitset<64> snomasks;
 
        ChanList chans;
 
        Server* server;
 
        std::string awaymsg;
 
        time_t awaytime;
 
        reference<OperInfo> oper;
 
        unsigned int registered:3;
 
        unsigned int quitting:1;
 
        const UserType usertype:2;
 
        const std::string& GetIPString();
 
        const std::string& GetHost(bool uncloak) const;
 
        const std::string& GetDisplayedHost() const;
 
        const std::string& GetRealHost() const;
 
        const std::string& GetRealName() const;
 
        irc::sockets::cidr_mask GetCIDRMask();
 
        virtual bool SetClientIP(const std::string& address);
 
        virtual void SetClientIP(const irc::sockets::sockaddrs& sa);
 
        User(const std::string& uid, Server* srv, UserType objtype);
 
        virtual const std::string& GetFullHost();
 
        virtual const std::string& GetFullRealHost();
 
        void InvalidateCache();
 
        bool IsAway() const { return (!awaymsg.empty()); }
 
        bool IsOper() const { return oper; }
 
        bool IsNoticeMaskSet(unsigned char sm);
 
        std::string GetModeLetters(bool includeparams = false) const;
 
        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;
 
        void SetMode(ModeHandler* mh, bool value);
        void SetMode(ModeHandler& mh, bool value) { SetMode(&mh, value); }
 
        virtual bool HasCommandPermission(const std::string& command);
 
        virtual bool HasPrivPermission(const std::string& privstr);
 
        virtual bool HasModePermission(const ModeHandler* mh) const;
 
        const std::string& MakeHost();
 
        const std::string& MakeHostIP();
 
        void Oper(OperInfo* info);
 
        void UnOper();
 
        void WriteNotice(const std::string& text);
 
        virtual void WriteRemoteNotice(const std::string& text);
 
        virtual void WriteRemoteNumeric(const Numeric::Numeric& numeric);
 
        template <typename T1>
        void WriteRemoteNumeric(unsigned int numeric, T1 p1)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                WriteRemoteNumeric(n);
        }
 
        template <typename T1, typename T2>
        void WriteRemoteNumeric(unsigned int numeric, T1 p1, T2 p2)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                WriteRemoteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3>
        void WriteRemoteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                WriteRemoteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3, typename T4>
        void WriteRemoteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3, T4 p4)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                n.push(p4);
                WriteRemoteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3, typename T4, typename T5>
        void WriteRemoteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                n.push(p4);
                n.push(p5);
                WriteRemoteNumeric(n);
        }
 
        void WriteNumeric(const Numeric::Numeric& numeric);
 
        template <typename T1>
        void WriteNumeric(unsigned int numeric, T1 p1)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                WriteNumeric(n);
        }
 
        template <typename T1, typename T2>
        void WriteNumeric(unsigned int numeric, T1 p1, T2 p2)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                WriteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3>
        void WriteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                WriteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3, typename T4>
        void WriteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3, T4 p4)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                n.push(p4);
                WriteNumeric(n);
        }
 
        template <typename T1, typename T2, typename T3, typename T4, typename T5>
        void WriteNumeric(unsigned int numeric, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
        {
                Numeric::Numeric n(numeric);
                n.push(p1);
                n.push(p2);
                n.push(p3);
                n.push(p4);
                n.push(p5);
                WriteNumeric(n);
        }
 
        void WriteCommonRaw(ClientProtocol::Event& protoev, bool include_self = true);
 
        void ForEachNeighbor(ForEachNeighborHandler& handler, bool include_self = true);
 
        bool SharesChannelWith(User *other);
 
        bool ChangeDisplayedHost(const std::string& host);
 
        void ChangeRealHost(const std::string& host, bool resetdisplay);
 
        bool ChangeIdent(const std::string& newident);
 
        bool ChangeRealName(const std::string& real);
 
        bool ChangeNick(const std::string& newnick, time_t newts = 0);
 
        void PurgeEmptyChannels();
 
        virtual ~User();
        CullResult cull() CXX11_OVERRIDE;
 
        bool Deserialize(Data& data) CXX11_OVERRIDE;
 
        bool Serialize(Serializable::Data& data) CXX11_OVERRIDE;
};
 
class CoreExport UserIOHandler : public StreamSocket
{
 private:
         size_t checked_until;
 public:
        LocalUser* const user;
        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;
 
        void AddWriteBuf(const std::string &data);
 
        void SwapInternals(UserIOHandler& other);
};
 
typedef unsigned int already_sent_t;
 
class CoreExport LocalUser : public User, public insp::intrusive_list_node<LocalUser>
{
        void Write(const ClientProtocol::SerializedMessage& serialized);
 
        void Send(ClientProtocol::Event& protoev, ClientProtocol::MessageList& msglist);
 
        static ClientProtocol::MessageList sendmsglist;
 
 public:
        LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
        LocalUser(int fd, const std::string& uuid, Serializable::Data& data);
 
        CullResult cull() CXX11_OVERRIDE;
 
        UserIOHandler eh;
 
        ClientProtocol::Serializer* serializer;
 
        unsigned int bytes_in;
 
        unsigned int bytes_out;
 
        unsigned int cmds_in;
 
        unsigned int cmds_out;
 
        std::string password;
 
        reference<ConnectClass> MyClass;
 
        ConnectClass* GetClass() const { return MyClass; }
 
        void CheckClass(bool clone_count = true);
 
        irc::sockets::sockaddrs server_sa;
 
        unsigned int quitting_sendq:1;
 
        unsigned int lastping:1;
 
        unsigned int exempt:1;
 
        time_t nextping;
 
        time_t idle_lastmsg;
 
        unsigned int CommandFloodPenalty;
 
        already_sent_t already_sent;
 
        bool CheckLines(bool doZline = false);
 
        void FullConnect();
 
        void SetClass(const std::string &explicit_name = "");
 
        bool SetClientIP(const std::string& address) CXX11_OVERRIDE;
 
        void SetClientIP(const irc::sockets::sockaddrs& sa) CXX11_OVERRIDE;
 
        void WriteRemoteNotice(const std::string& text) CXX11_OVERRIDE;
 
        bool HasCommandPermission(const std::string& command) CXX11_OVERRIDE;
 
        bool HasPrivPermission(const std::string& privstr) CXX11_OVERRIDE;
 
        bool HasModePermission(const ModeHandler* mh) const CXX11_OVERRIDE;
 
        void OverruleNick();
 
        void Send(ClientProtocol::Event& protoev);
 
        void Send(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg);
 
        bool Deserialize(Data& data) CXX11_OVERRIDE;
 
        bool Serialize(Serializable::Data& data) CXX11_OVERRIDE;
};
 
class RemoteUser : public User
{
 public:
        RemoteUser(const std::string& uid, Server* srv) : User(uid, srv, USERTYPE_REMOTE)
        {
        }
};
 
class CoreExport FakeUser : public User
{
 public:
        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(uid, sname, sdesc), USERTYPE_SERVER)
        {
                nick = sname;
        }
 
        CullResult cull() CXX11_OVERRIDE;
        const std::string& GetFullHost() CXX11_OVERRIDE;
        const std::string& GetFullRealHost() CXX11_OVERRIDE;
};
 
/* Faster than dynamic_cast */
inline LocalUser* IS_LOCAL(User* u)
{
        return (u != NULL && u->usertype == USERTYPE_LOCAL) ? static_cast<LocalUser*>(u) : NULL;
}
inline RemoteUser* IS_REMOTE(User* u)
{
        return (u != NULL && u->usertype == USERTYPE_REMOTE) ? static_cast<RemoteUser*>(u) : NULL;
}
inline FakeUser* IS_SERVER(User* u)
{
        return (u != NULL && u->usertype == USERTYPE_SERVER) ? static_cast<FakeUser*>(u) : NULL;
}
 
inline bool User::IsModeSet(const ModeHandler* mh) const
{
        return ((mh->GetId() != ModeParser::MODEID_MAX) && (modes[mh->GetId()]));
}
 
inline bool User::IsModeSet(UserModeReference& moderef) const
{
        if (!moderef)
                return false;
        return IsModeSet(*moderef);
}
 
inline void User::SetMode(ModeHandler* mh, bool value)
{
        if (mh && mh->GetId() != ModeParser::MODEID_MAX)
                modes[mh->GetId()] = value;
}