xline.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
 *   Copyright (C) 2004-2007 Craig Edwards <craigedwards@brainbox.cc>
 *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
 *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
 *
 * 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 XLINE_H
#define XLINE_H

class CoreExport XLine : public classbase
{
 protected:

        void DefaultApply(User* u, const std::string &line, bool bancache);

 public:

        XLine(time_t s_time, long d, std::string src, std::string re, const std::string &t)
                : set_time(s_time), duration(d), source(src), reason(re), type(t)
        {
                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() = 0;

        virtual const char* Displayable() = 0;

        virtual void OnAdd() { }

        time_t set_time;

        long duration;

        std::string source;

        std::string reason;

        time_t expiry;

        const std::string type;

        virtual bool IsBurstable();
};

class CoreExport KLine : public XLine
{
  public:

        KLine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
                : XLine(s_time, d, src, re, "K"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }

        ~KLine()
        {
        }

        virtual bool Matches(User *u);

        virtual bool Matches(const std::string &str);

        virtual void Apply(User* u);

        virtual void DisplayExpiry();

        virtual const char* Displayable();

        virtual bool IsBurstable();

        std::string identmask;
        std::string hostmask;

        std::string matchtext;
};

class CoreExport GLine : public XLine
{
  public:
        GLine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
                : XLine(s_time, d, src, re, "G"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }

        ~GLine()
        {
        }

        virtual bool Matches(User *u);

        virtual bool Matches(const std::string &str);

        virtual void Apply(User* u);

        virtual void DisplayExpiry();

        virtual const char* Displayable();

        std::string identmask;
        std::string hostmask;

        std::string matchtext;
};

class CoreExport ELine : public XLine
{
  public:
        ELine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
                : XLine(s_time, d, src, re, "E"), identmask(ident), hostmask(host)
        {
                matchtext = this->identmask;
                matchtext.append("@").append(this->hostmask);
        }

        ~ELine()
        {
        }

        virtual bool Matches(User *u);

        virtual bool Matches(const std::string &str);

        virtual void Unset();

        virtual void DisplayExpiry();

        virtual void OnAdd();

        virtual const char* Displayable();

        std::string identmask;
        std::string hostmask;

        std::string matchtext;
};

class CoreExport ZLine : public XLine
{
  public:
        ZLine(time_t s_time, long d, std::string src, std::string re, std::string ip)
                : XLine(s_time, d, src, re, "Z"), ipaddr(ip)
        {
        }

        ~ZLine()
        {
        }

        virtual bool Matches(User *u);

        virtual bool Matches(const std::string &str);

        virtual void Apply(User* u);

        virtual void DisplayExpiry();

        virtual const char* Displayable();

        std::string ipaddr;
};

class CoreExport QLine : public XLine
{
  public:
        QLine(time_t s_time, long d, std::string src, std::string re, std::string nickname)
                : XLine(s_time, d, src, re, "Q"), nick(nickname)
        {
        }

        ~QLine()
        {
        }
        virtual bool Matches(User *u);

        virtual bool Matches(const std::string &str);

        virtual void Apply(User* u);

        virtual void DisplayExpiry();

        virtual const char* Displayable();

        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, long duration, std::string source, std::string reason, 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, 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);

        void ApplyLines();

        void InvokeStats(const std::string &type, int numeric, User* user, string_list &results);
};

#endif