KviIrcConnection.h

Go to the documentation of this file.

#ifndef _KVI_IRCCONNECTION_H_
#define _KVI_IRCCONNECTION_H_
//=============================================================================
//
//   File : KviIrcConnection.h
//   Creation date : Mon 03 May 2004 01:45:42 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 "KviPointerList.h"
#include "KviTimeUtils.h"

#include <QObject>
#include <QByteArray>
#include <QStringList>
#include <QList>
#include <QPair>

class QTimer;
class QTextCodec;
class KviConsoleWindow;
class KviIrcNetworkData;
class KviIrcServer;
class KviProxy;
class KviIrcSocket;
class KviIrcLink;
class KviDataBuffer;
class KviIrcContext;
class KviMainWindow;
class KviChannelWindow;
class KviQueryWindow;
class KviIrcConnectionTarget;
class KviIrcUserDataBase;
class KviIrcConnectionUserInfo;
class KviIrcConnectionServerInfo;
class KviIrcConnectionStateData;
class KviIrcConnectionAntiCtcpFloodData;
class KviIrcConnectionNetsplitDetectorData;
class KviIrcConnectionAsyncWhoisData;
class KviIrcConnectionStatistics;
class KviIrcConnectionRequestQueue;
class KviLagMeter;
class KviNotifyListManager;
class KviDnsResolver;
class KviUserIdentity;
class KviIdentityProfileSet;
class KviCString;

class KVIRC_API KviIrcConnection : public QObject
{
        friend class KviConsoleWindow;
        friend class KviIrcContext;
        friend class KviIrcLink;
        friend class KviIrcServerParser;
        Q_OBJECT
protected:
        KviIrcConnection(KviIrcContext * pContext, KviIrcConnectionTarget * pTarget, KviUserIdentity * pIdentity);

        ~KviIrcConnection();

public:
        enum State
        {
                Idle,       
                Connecting, 
                Connected   
        };

private:
        KviConsoleWindow * m_pConsole; // shallow, never null
        KviIrcContext * m_pContext;    // shallow, never null

        State m_eState;
        bool m_bIdentdAttached;

        KviIrcConnectionTarget * m_pTarget; // owned, never null

        KviIrcLink * m_pLink; // owned, never null

        // The initial information about the user we'll send out to the server
        // Note that the ACTUAL user information are in m_pUserInfo instead
        KviUserIdentity * m_pUserIdentity; // owned, never null

        // The ACTUAL user information
        KviIrcConnectionUserInfo * m_pUserInfo; // owned, never null
        // The ACTUAL server information
        KviIrcConnectionServerInfo * m_pServerInfo; // owned, never null

        KviIrcConnectionStateData * m_pStateData; // owned, never null

        KviPointerList<KviChannelWindow> * m_pChannelList; // owned, never null, elements shallow
        KviPointerList<KviQueryWindow> * m_pQueryList;     // owned, never null, elements shallow

        KviIrcUserDataBase * m_pUserDataBase; // owned, never null

        KviNotifyListManager * m_pNotifyListManager; // owned, see restartNotifyList()
        QTimer * m_pNotifyListTimer;                 // delayed startup timer for the notify lists

        KviLagMeter * m_pLagMeter; // owned, may be null (when not running)

        KviIrcConnectionAntiCtcpFloodData * m_pAntiCtcpFloodData;       // owned, never null
        KviIrcConnectionNetsplitDetectorData * m_pNetsplitDetectorData; // owned, never null
        KviIrcConnectionAsyncWhoisData * m_pAsyncWhoisData;             // owned, never null

        KviIrcConnectionStatistics * m_pStatistics; // owned, never null

        KviDnsResolver * m_pLocalhostDns; // FIXME: this should go to an aux structure

        QTextCodec * m_pSrvCodec;                       // connection codec: never null
        QTextCodec * m_pTextCodec;                      // connection codec: never null
        KviIrcConnectionRequestQueue * m_pRequestQueue; // owned, never null
public:
        inline KviConsoleWindow * console() { return m_pConsole; };

        inline KviIrcContext * context() { return m_pContext; };

        inline KviIrcConnectionTarget * target() { return m_pTarget; };

        inline KviIrcLink * link() { return m_pLink; };

        inline State state() { return m_eState; };

        inline KviIrcUserDataBase * userDataBase() { return m_pUserDataBase; };

        inline KviIrcConnectionUserInfo * userInfo() { return m_pUserInfo; };

        inline KviIrcConnectionServerInfo * serverInfo() { return m_pServerInfo; };

        inline KviIrcConnectionStateData * stateData() { return m_pStateData; };

        inline KviIrcConnectionAntiCtcpFloodData * antiCtcpFloodData()
        {
                return m_pAntiCtcpFloodData;
        };

        inline KviIrcConnectionNetsplitDetectorData * netsplitDetectorData()
        {
                return m_pNetsplitDetectorData;
        };

        inline KviIrcConnectionAsyncWhoisData * asyncWhoisData()
        {
                return m_pAsyncWhoisData;
        };

        inline KviIrcConnectionStatistics * statistics() { return m_pStatistics; };

        inline KviNotifyListManager * notifyListManager()
        {
                return m_pNotifyListManager;
        };

        inline KviLagMeter * lagMeter() { return m_pLagMeter; };

        inline KviIrcConnectionRequestQueue * requestQueue() { return m_pRequestQueue; };

        inline KviPointerList<KviChannelWindow> * channelList() { return m_pChannelList; };

        const QString & currentNetworkName();

        const QString & currentNickName();

        const QString & currentUserName();

        const QString & currentServerName();

        //
        // Channel management
        //
        // FIXME: Delegate to a KviChannelManager
        //

        KviChannelWindow * findChannel(const QString & szName);

        int getCommonChannels(const QString & szNick, QString & szChansBuffer, bool bAddEscapeSequences = true);

        KviChannelWindow * createChannel(const QString & szName);

        void registerChannel(KviChannelWindow * c);

        void unregisterChannel(KviChannelWindow * c);

        void keepChannelsOpenAfterDisconnect();

        void closeAllChannels();

        void closeAllQueries();

        //
        // Query management
        //
        // FIXME: Delegate to a KviQueryManager ?
        //

        KviQueryWindow * findQuery(const QString & szNick);

        inline KviPointerList<KviQueryWindow> * queryList() { return m_pQueryList; };

        enum CreateQueryVisibilityMode
        {
                CreateQueryVisibilityMinimized,
                CreateQueryVisibilityVisible,
                CreateQueryVisibilityFollowSettings
        };

        KviQueryWindow * createQuery(const QString & szNick, CreateQueryVisibilityMode eVisibilityMode = CreateQueryVisibilityFollowSettings);

        void registerQuery(KviQueryWindow * q);

        void unregisterQuery(KviQueryWindow * q);

        void keepQueriesOpenAfterDisconnect();

        void resurrectDeadQueries();

        void restartLagMeter();

        //
        // Networking stack public stuff
        //

        bool sendData(const char * pcBuffer, int iBuflen = -1);

        bool sendFmtData(const char * pcFmt, ...);

        void clearOutputQueue(bool bPrivateMessagesOnly);

        unsigned int outputQueueSize();

        void incomingMessage(const char * pcMessage);

        void incomingMessageNoFilter(const char * pcMessage);

        //
        // Encoding related stuff
        //

        inline QTextCodec * textCodec() { return m_pTextCodec; };

        inline QTextCodec * serverCodec() { return m_pSrvCodec; };

        void setEncoding(const QString & szEncoding);

        QString decodeText(const char * szText);

        QByteArray encodeText(const QString & szText);

protected:
        //
        // Notify list management
        //

        void delayedStartNotifyList();

        //
        // Login operations
        //

        void resolveLocalHost();

#ifdef COMPILE_SSL_SUPPORT
        void handleFailedInitialStartTls();
        bool trySTARTTLS(bool bAppendPing);
        void enableStartTlsSupport(bool bEnable);
#endif

        void useProfileData(KviIdentityProfileSet * pSet, const QString & szNetwork);

        void useRealName(const QString & szRealName);

        void loginToIrcServer();

        void joinChannels(const QList<QPair<QString, QString>> & lChannelsAndPasses);

        void gatherChannelAndPasswordPairs(QList<QPair<QString, QString>> & lChannelsAndPasses);

        void gatherQueryNames(QStringList & lQueryNames);

        QString pickNextLoginNickName(bool bForceDefaultIfPrimaryNicknamesEmpty, const QString & szBaseNickForRandomChoices, QString & szChoiceDescriptionBuffer);

        //
        // KviIrcServerParser interface
        //

        void endOfMotdReceived();

        void serverInfoReceived(const QString & szServerName, const QString & szUserModes, const QString & szChanModes);

        void handleAuthenticate(KviCString & szResponse);

        void handleInitialCapLs();

        void handleFailedInitialCapLs();

        void handleInitialCapAck();

        void handleInitialCapNak();

        void endInitialCapNegotiation();

        void changeAwayState(bool bAway);

        void userInfoReceived(const QString & szUserName, const QString & szHostName);

        void nickChange(const QString & szNewNick);

        bool changeUserMode(char cMode, bool bSet);

        void loginComplete(const QString & szNickName);

        //
        // KviIrcContext interface
        //

        void start();

        void abort();

        void heartbeat(kvi_time_t tNow);

        //
        // KviIrcLink interface (down)
        //

        void linkAttemptFailed(int iError);

        void linkEstablished();

        void linkTerminated();

private:
        void setupTextCodec();

        void setupSrvCodec();
public slots:
        void unhighlightAllChannels();

        void unhighlightAllQueries();

        void restartNotifyList();
private slots:
        void hostNameLookupTerminated(KviDnsResolver * pDns);
signals:
        void awayStateChanged();

        void userModeChanged();

        void nickNameChanged();

        void channelRegistered(KviChannelWindow * pChan);

        void channelUnregistered(KviChannelWindow * pChan);

        void chanListChanged();
};

// TODO: KviIdentity

#endif //_KVI_IRCCONNECTION_H_