KviIrcConnectionServerInfo.h

Go to the documentation of this file.

#ifndef _KVI_IRCCONNECTIONSERVERINFO_H_
#define _KVI_IRCCONNECTIONSERVERINFO_H_
//=============================================================================
//
//   File : KviIrcConnectionServerInfo.h
//   Creation date : Tue 22 Jun 2004 03:57:32 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2004-2010 Szymon Stefanek <pragma at kvirc dot net>
//
//   This program 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; either version 2
//   of the License, or (at your option) any later version.
//
//   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, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "kvi_settings.h"
#include "KviQString.h"
#include "kvi_inttypes.h"

#include <QStringList>

class KviIrcConnectionServerInfo;

class KVIRC_API KviBasicIrcServerInfo
{
        // ircnet
protected:
        QString m_szServerVersion;
        KviIrcConnectionServerInfo * m_pParent;

public:
        KviBasicIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty);
        virtual ~KviBasicIrcServerInfo();

public:
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 0; };
        virtual const char * getSoftware() { return "Ircd"; };
        virtual bool getNeedsOpToListModeseI() { return false; };
        virtual bool getNeedsOperToSetS() { return false; };
};

// Hybrid + forks

class KVIRC_API KviHybridServerInfo : public KviBasicIrcServerInfo
{
        // This is a major IRCd that most modern forks are based off of
public:
        KviHybridServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "Hybrid"; };
};

class KVIRC_API KviIrcdRatboxIrcServerInfo : public KviHybridServerInfo
{
        // efnet
public:
        KviIrcdRatboxIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviHybridServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 0; };
        virtual const char * getSoftware() { return "Ircd-ratbox"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
};

class KVIRC_API KviCharybdisServerInfo : public KviIrcdRatboxIrcServerInfo
{
public:
        KviCharybdisServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviIrcdRatboxIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual const char * getSoftware() { return "Charybdis"; };
        virtual bool getNeedsOperToSetS() { return true; };
};

class KVIRC_API KviIrcdSevenIrcServerInfo : public KviCharybdisServerInfo
{
        // freenode
public:
        KviIrcdSevenIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviCharybdisServerInfo(pParent, version) { ; };
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 0; };
        virtual const char * getSoftware() { return "Ircd-seven"; };
};

class KVIRC_API KviPlexusIrcServerInfo : public KviHybridServerInfo
{
        // rizon; note: plexus is an extension to hybrid
public:
        KviPlexusIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviHybridServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual const char * getSoftware() { return "Plexus"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
};

class KVIRC_API KviOftcIrcServerInfo : public KviHybridServerInfo
{
        // oftc; note: hybrid+oftc is an extension to hybrid
public:
        KviOftcIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviHybridServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'R'; };
        virtual const char * getSoftware() { return "Hybrid+Oftc"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
};

// P10

class KVIRC_API KviIrcuIrcServerInfo : public KviBasicIrcServerInfo
{
        // undernet
public:
        KviIrcuIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 0; };
        virtual const char * getSoftware() { return "Ircu"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
        virtual bool getNeedsOperToSetS() { return true; };
};

class KVIRC_API KviSnircdIrcServerInfo : public KviIrcuIrcServerInfo
{
        // quakenet; note: snird is an extension to ircu
public:
        KviSnircdIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviIrcuIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual const char * getSoftware() { return "Snircd"; };
        virtual bool getNeedsOperToSetS() { return true; };
};

class KVIRC_API KviDarenetIrcServerInfo : public KviIrcuIrcServerInfo
{
        // darenet; note: u2+ircd-darenet is an extension to ircu
public:
        KviDarenetIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviIrcuIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "Ircu+Darenet"; };
        virtual bool getNeedsOpToListModeseI() { return false; };
};

// Unreal -> Unreal 3.2 -> Unreal 4.0

class KVIRC_API KviUnrealIrcServerInfo : public KviBasicIrcServerInfo
{
public:
        KviUnrealIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "Unreal"; };
        virtual bool getNeedsOpToListModeseI() { return false; };
        virtual bool getNeedsOperToSetS() { return true; };
};

class KVIRC_API KviUnreal32IrcServerInfo : public KviUnrealIrcServerInfo
{
        // This is a continuation on to Unreal, so use its predecessor
        // as a base class.
public:
        KviUnreal32IrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviUnrealIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual const char * getSoftware() { return "Unreal32"; };
};

class KVIRC_API KviUnreal40IrcServerInfo : public KviUnreal32IrcServerInfo
{
public:
        KviUnreal40IrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviUnreal32IrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const char * getSoftware() { return "Unreal40"; };
};

class KVIRC_API KviCritenIrcServerInfo : public KviBasicIrcServerInfo
{
        // abjects
public:
        KviCritenIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "Criten"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
};

class KVIRC_API KviNemesisIrcServerInfo : public KviCritenIrcServerInfo
{
        // criten
public:
        KviNemesisIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviCritenIrcServerInfo(pParent, version) { ; };
        virtual const char * getSoftware() { return "Nemesis"; };
};

class KVIRC_API KviNemesis20IrcServerInfo : public KviUnreal32IrcServerInfo
{
public:
        KviNemesis20IrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviUnreal32IrcServerInfo(pParent, version) { ; };
        virtual const char * getSoftware() { return "Nemesis2.0"; };
        virtual bool getNeedsOperToSetS() { return false; };
};

class KVIRC_API KviBahamutIrcServerInfo : public KviBasicIrcServerInfo
{
        // dalnet, azzurranet
public:
        KviBahamutIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "Bahamut"; };
        virtual bool getNeedsOpToListModeseI() { return false; };
};

class KVIRC_API KviHyperionIrcServerInfo : public KviBasicIrcServerInfo
{
        // legacy freenode : no longer maintained
public:
        KviHyperionIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'e'; };
        virtual const char * getSoftware() { return "Hyperion"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
};

class KVIRC_API KviInspIRCdIrcServerInfo : public KviBasicIrcServerInfo
{
        // chatspike
public:
        KviInspIRCdIrcServerInfo(KviIrcConnectionServerInfo * pParent = 0, const QString & version = KviQString::Empty)
            : KviBasicIrcServerInfo(pParent, version) { ; };
        virtual const QString & getChannelModeDescription(char mode);
        virtual const QString & getUserModeDescription(QChar mode);
        virtual QChar getUserModeRequirement(QChar mode);
        virtual char getRegisterModeChar() { return 'r'; };
        virtual const char * getSoftware() { return "InspIRCd"; };
        virtual bool getNeedsOpToListModeseI() { return true; };
        virtual bool getNeedsOperToSetS() { return true; };
};

class KVIRC_API KviIrcConnectionServerInfo
{
        friend class KviConsoleWindow; // for now
        friend class KviIrcServerParser;
        friend class KviIrcConnection;

protected:
        KviIrcConnectionServerInfo();
        ~KviIrcConnectionServerInfo();

private:
        KviBasicIrcServerInfo * m_pServInfo;
        QString m_szNetworkName;           // the most actual network name (may be the one we specify or the one that the server reports)
        QString m_szName;                  // the most actual server name (may be the one we specify or the one that the server wants to be known as)
        QString m_szSupportedUserModes;    // the supported user modes
        QString m_szSupportedChannelModes; // the supported channel modes (all of them)
        QString m_szSupportedModePrefixes; // the actually used mode prefixes  @+
        kvi_u32_t * m_pModePrefixTable;    // the mode prefixes above in a table
        unsigned int m_uPrefixes;
        QString m_szSupportedModeFlags;    // the actually used mode flags     ov
        QString m_szSupportedChannelTypes; // the supported channel types
        bool m_bSupportsWatchList;         // supports the watch list ?
        bool m_bSupportsCodePages;         // supports the /CODEPAGE command ?
        int m_iMaxTopicLen;
        int m_iMaxModeChanges;
        // Mode that adds or removes a nick or address to a list. Always has a parameter (eg: "b" as ban)
        QString m_szListModes;
        // Mode that changes a setting and always has a parameter (eg: "k" as channel key)
        QString m_szParameterModes;
        // Mode that changes a setting and only has a parameter when set (eg: "l" as channel limit)
        QString m_szParameterWhenSetModes;
        // Mode that changes a setting and never has a parameter (eg: "m" as channel moderated)
        QString m_szPlainModes;
        bool m_bSupportsCap;
        QStringList m_lSupportedCaps;
        bool m_bSupportsWhox; // supports WHOX
public:
        char registerModeChar() { return m_pServInfo ? m_pServInfo->getRegisterModeChar() : 0; };
        const char * software() { return m_pServInfo ? m_pServInfo->getSoftware() : 0; };
        bool getNeedsOpToListModeseI() { return m_pServInfo ? m_pServInfo->getNeedsOpToListModeseI() : false; };
        bool getNeedsOperToSetS() { return m_pServInfo ? m_pServInfo->getNeedsOperToSetS() : false; };
        const QString & name() { return m_szName; };
        const QString & networkName() { return m_szNetworkName; };
        const QString & supportedUserModes() { return m_szSupportedUserModes; };
        const QString & supportedChannelModes() { return m_szSupportedChannelModes; };
        const QString & supportedChannelTypes() { return m_szSupportedChannelTypes; };
        const QString & supportedModePrefixes() { return m_szSupportedModePrefixes; };
        const QString & supportedModeFlags() { return m_szSupportedModeFlags; };
        const QString & supportedListModes() { return m_szListModes; };
        const QString & supportedParameterModes() { return m_szParameterModes; };
        const QString & supportedParameterWhenSetModes() { return m_szParameterWhenSetModes; };
        const QString & supportedPlainModes() { return m_szPlainModes; };
        bool supportsCap() { return m_bSupportsCap; };
        const QStringList & supportedCaps() { return m_lSupportedCaps; };
        bool supportsWatchList() { return m_bSupportsWatchList; };
        bool supportsCodePages() { return m_bSupportsCodePages; };
        bool supportsWhox() { return m_bSupportsWhox; };

        int maxTopicLen() { return m_iMaxTopicLen; };
        int maxModeChanges() { return m_iMaxModeChanges; };

        void setServerVersion(const QString & version);

        const QString & getChannelModeDescription(char mode) { return m_pServInfo->getChannelModeDescription(mode); };
        const QString & getUserModeDescription(QChar mode) { return m_pServInfo->getUserModeDescription(mode); };

        // Returning ! means the mode can never be set by the user. Returning QChar::Null means the mode is free to set.
        // Returning a QChar means the mode has another mode dependency (the QChar we're returning)
        QChar getUserModeRequirement(QChar mode) { return m_pServInfo ? m_pServInfo->getUserModeRequirement(mode) : QChar::Null; };

        bool isSupportedChannelType(QChar c);
        bool isSupportedModePrefix(QChar c);
        bool isSupportedModeFlag(QChar c);
        QChar modePrefixChar(kvi_u32_t flag);
        QChar modeFlagChar(kvi_u32_t flag);
        kvi_u32_t modeFlagFromPrefixChar(QChar c);
        kvi_u32_t modeFlagFromModeChar(QChar c);

protected:
        void setNetworkName(const QString & szName) { m_szNetworkName = szName; };
        void setName(const QString & szName) { m_szName = szName; };
        void setSupportedUserModes(const QString & szSupportedUserModes) { m_szSupportedUserModes = szSupportedUserModes; };
        void setSupportedChannelModes(const QString & szSupportedChannelModes);
        void setSupportedModePrefixes(const QString & szSupportedModePrefixes, const QString & szSupportedModeFlags);
        void setSupportedChannelTypes(const QString & szSupportedChannelTypes) { m_szSupportedChannelTypes = szSupportedChannelTypes; };
        void setSupportsWatchList(bool bSupportsWatchList) { m_bSupportsWatchList = bSupportsWatchList; };
        void setSupportsCodePages(bool bSupportsCodePages) { m_bSupportsCodePages = bSupportsCodePages; };
        void addSupportedCaps(const QString & szCapList);
        void setMaxTopicLen(int iTopLen) { m_iMaxTopicLen = iTopLen; };
        void setMaxModeChanges(int iModes) { m_iMaxModeChanges = iModes; };
        void setSupportsWhox(bool bSupportsWhox) { m_bSupportsWhox = bSupportsWhox; };
private:
        void buildModePrefixTable();
};

#endif