xline.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2019 Matt Schatz <[email protected]>
 *   Copyright (C) 2013, 2016 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2013, 2017-2018 Sadie Powell <[email protected]>
 *   Copyright (C) 2012, 2018-2019 Robby <[email protected]>
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *   Copyright (C) 2006-2008, 2010 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
 
class CoreExport XLine : public classbase
{
 protected:
 
        void DefaultApply(User* u, const std::string &line, bool bancache);
 
 public:
 
        XLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& t)
                : set_time(s_time)
                , duration(d)
                , source(src)
                , reason(re)
                , type(t)
                , from_config(false)
        {
                expiry = set_time + duration;
        }
 
        virtual ~XLine()
        {
        }
 
        virtual void SetCreateTime(time_t created)
        {
                set_time = created;
                expiry = created + duration;
        }
 
        virtual bool Matches(User *u) = 0;
 
        virtual bool Matches(const std::string &str) = 0;
 
        virtual void Apply(User* u);
 
        virtual void Unset() { }
 
        virtual void DisplayExpiry();
 
        virtual const std::string& Displayable() = 0;
 
        virtual void OnAdd() { }
 
        time_t set_time;
 
        unsigned long duration;
 
        std::string source;
 
        std::string reason;
 
        time_t expiry;
 
        const std::string type;
 
        // Whether this XLine was loaded from the server config.
        bool from_config;
 
        virtual bool IsBurstable();
};
 
class CoreExport KLine : public XLine
{
  public:
 
        KLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ident, const std::string& host)
                : XLine(s_time, d, src, re, "K"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }
 
        ~KLine()
        {
        }
 
        bool Matches(User* u) CXX11_OVERRIDE;
 
        bool Matches(const std::string& str) CXX11_OVERRIDE;
 
        void Apply(User* u) CXX11_OVERRIDE;
 
        const std::string& Displayable() CXX11_OVERRIDE;
 
        bool IsBurstable() CXX11_OVERRIDE;
 
        std::string identmask;
        std::string hostmask;
 
        std::string matchtext;
};
 
class CoreExport GLine : public XLine
{
  public:
        GLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ident, const std::string& host)
                : XLine(s_time, d, src, re, "G"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }
 
        ~GLine()
        {
        }
 
        bool Matches(User* u) CXX11_OVERRIDE;
 
        bool Matches(const std::string& str) CXX11_OVERRIDE;
 
        void Apply(User* u)  CXX11_OVERRIDE;
 
        const std::string& Displayable() CXX11_OVERRIDE;
 
        std::string identmask;
        std::string hostmask;
 
        std::string matchtext;
};
 
class CoreExport ELine : public XLine
{
  public:
        ELine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ident, const std::string& host)
                : XLine(s_time, d, src, re, "E"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }
 
        ~ELine()
        {
        }
 
        bool Matches(User* u) CXX11_OVERRIDE;
 
        bool Matches(const std::string& str) CXX11_OVERRIDE;
 
        void Unset() CXX11_OVERRIDE;
 
        void OnAdd() CXX11_OVERRIDE;
 
        const std::string& Displayable() CXX11_OVERRIDE;
 
        std::string identmask;
        std::string hostmask;
 
        std::string matchtext;
};
 
class CoreExport ZLine : public XLine
{
  public:
        ZLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& ip)
                : XLine(s_time, d, src, re, "Z"), ipaddr(ip)
        {
        }
 
        ~ZLine()
        {
        }
 
        bool Matches(User* u) CXX11_OVERRIDE;
 
        bool Matches(const std::string& str) CXX11_OVERRIDE;
 
        void Apply(User* u) CXX11_OVERRIDE;
 
        const std::string& Displayable() CXX11_OVERRIDE;
 
        std::string ipaddr;
};
 
class CoreExport QLine : public XLine
{
  public:
        QLine(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& nickname)
                : XLine(s_time, d, src, re, "Q"), nick(nickname)
        {
        }
 
        ~QLine()
        {
        }
        bool Matches(User* u) CXX11_OVERRIDE;
 
        bool Matches(const std::string& str) CXX11_OVERRIDE;
 
        void Apply(User* u) CXX11_OVERRIDE;
 
        const std::string& Displayable() CXX11_OVERRIDE;
 
        std::string nick;
};
 
class CoreExport XLineFactory
{
 protected:
 
        std::string type;
 
 public:
 
        XLineFactory(const std::string &t) : type(t) { }
 
        virtual const std::string& GetType() { return type; }
 
        virtual XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) = 0;
 
        virtual bool AutoApplyToUserList(XLine* x) { return true; }
 
        virtual ~XLineFactory() { }
};
 
class CoreExport XLineManager
{
 protected:
        std::vector<XLine *> pending_lines;
 
        XLineFactMap line_factory;
 
        XLineContainer lookup_lines;
 
 public:
 
        XLineManager();
 
        ~XLineManager();
 
        IdentHostPair IdentSplit(const std::string &ident_and_host);
 
        void CheckELines();
 
        XLineLookup* GetAll(const std::string &type);
 
        void DelAll(const std::string &type);
 
        std::vector<std::string> GetAllTypes();
 
        bool AddLine(XLine* line, User* user);
 
        bool DelLine(const char* hostmask, const std::string& type, std::string& reason, User* user, bool simulate = false);
 
        bool RegisterFactory(XLineFactory* xlf);
 
        bool UnregisterFactory(XLineFactory* xlf);
 
        XLineFactory* GetFactory(const std::string &type);
 
        XLine* MatchesLine(const std::string &type, User* user);
 
        XLine* MatchesLine(const std::string &type, const std::string &pattern);
 
        void ExpireLine(ContainerIter container, LookupIter item, bool silent = false);
 
        void ApplyLines();
 
        void InvokeStats(const std::string& type, unsigned int numeric, Stats::Context& stats);
 
        void ExpireRemovedConfigLines(const std::string& type, const insp::flat_set<std::string>& configlines);
};