xline.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2004-2007 Craig Edwards <[email protected]>
 *   Copyright (C) 2007 Robin Burchell <[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 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