KviIrcSocket.h

Go to the documentation of this file.

#ifndef _KVI_IRCSOCKET_H_
#define _KVI_IRCSOCKET_H_
//=============================================================================
//
//   File : KviIrcSocket.h
//   Creation date : Tue Jul 30 19:25:17 2002 GMT by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2002-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 "KviCString.h"
#include "kvi_sockettype.h"
#include "KviTimeUtils.h"
#include "KviPointerList.h"
#include "KviError.h"

#include <QObject>

class QTimer;
class QSocketNotifier;
class KviIrcServer;
class KviProxy;
class KviIrcConnection;
class KviIrcConnectionTarget;
class KviIrcLink;
class KviSSL;
class KviConsoleWindow;
class KviDataBuffer;

typedef struct _KviIrcSocketMsgEntry
{
        KviDataBuffer * pData;
        struct _KviIrcSocketMsgEntry * next_ptr;
} KviIrcSocketMsgEntry;

class KVIRC_API KviIrcSocket : public QObject
{
        Q_OBJECT
public:
        KviIrcSocket(KviIrcLink * pLink);

        ~KviIrcSocket();

public:
        enum SocketState
        {
                Idle,                    
                Connecting,              
                ProxyLogin,              
                ProxyHttpError,          
                Connected,               
                ProxyFinalV4,            
                ProxyFinalV5,            
                ProxyFinalHttp,          
                ProxySelectAuthMethodV5, 
                ProxyUserPassV5,         
                SSLHandshake             
        };

protected:
        unsigned int m_uId;
        KviIrcLink * m_pLink;
        KviConsoleWindow * m_pConsole;
        kvi_socket_t m_sock;
        SocketState m_state;
        QSocketNotifier * m_pWsn;
        QSocketNotifier * m_pRsn;
        KviIrcServer * m_pIrcServer;
        KviProxy * m_pProxy;
        QTimer * m_pTimeoutTimer;
        unsigned int m_uReadBytes;
        unsigned int m_uSentBytes;
        KviError::Code m_eLastError;
        unsigned int m_uSentPackets;
        KviIrcSocketMsgEntry * m_pSendQueueHead;
        KviIrcSocketMsgEntry * m_pSendQueueTail;
        QTimer * m_pFlushTimer;
        struct timeval m_tAntiFloodLastMessageTime;
        bool m_bInProcessData;
#ifdef COMPILE_SSL_SUPPORT
        KviSSL * m_pSSL;
#endif
public:
        KviConsoleWindow * console() { return m_pConsole; };

        KviIrcLink * link() { return m_pLink; };

        SocketState state() { return m_state; };

        int lastError() { return m_eLastError; };

        unsigned int id() { return m_uId; };

#ifdef COMPILE_SSL_SUPPORT
        bool usingSSL()
        {
                return m_pSSL;
        };
#else
        bool usingSSL()
        {
                return false;
        };
#endif

#ifdef COMPILE_SSL_SUPPORT

        KviSSL * getSSL() { return m_pSSL; };
#endif

        unsigned int readBytes() { return m_uReadBytes; };

        unsigned int sentBytes() { return m_uSentBytes; };

        unsigned int sentPackets() { return m_uSentPackets; };
        //unsigned int readPackets(){ return m_uReadPackets; };

        bool isConnected() { return m_state == Connected; };

        KviError::Code startConnection(KviIrcServer * pServer, KviProxy * pProxy = 0, const char * pcBindAddress = 0);

#ifdef COMPILE_SSL_SUPPORT

        void enterSSLMode();
#endif // COMPILE_SSL_SUPPORT

        bool sendPacket(KviDataBuffer * pData);

        void abort();

        bool getLocalHostIp(QString & szIp, bool bIPv6);

        void clearOutputQueue(bool bPrivateMessagesOnly);

        unsigned int outputQueueSize();

protected:
#ifdef COMPILE_SSL_SUPPORT

        void raiseSSLError();

        void printSSLPeerCertificate();

        void printSSLCipherInfo();
#endif // COMPILE_SSL_SUPPORT

        bool sendRawData(const char * pcBuffer, int iBufLen);

        void raiseError(KviError::Code eError);

        void connectionEstablished();

        void connectedToProxy();

        void connectedToIrcServer();

        void proxyLoginHttp();

        void proxyLoginV4();

        void proxyLoginV5();

        void proxyAuthUserPassV5();

        void proxySendTargetDataV5();

        void proxyHandleV5AuthReply(unsigned char cReply);

        void proxyHandleV5MethodReply(unsigned char cReply);

        void proxyHandleV5FinalReply(unsigned char cReply);

        void proxyHandleV4FinalReply(unsigned char cReply);

        void proxyHandleHttpFinalReply(const char * pcBuffer, int iBufLen);

        void linkUp();

        void handleInvalidSocketRead(int iReadLength);

        virtual void reset();

        void free_msgEntry(KviIrcSocketMsgEntry * e);

        virtual void queue_insertMessage(KviIrcSocketMsgEntry * pMsg);

        bool queue_removeMessage();

        void queue_removeAllMessages();

        void queue_removePrivateMessages();

        virtual void setState(SocketState state);

private:
        void outputSSLMessage(const QString & szMsg);

        void outputSSLError(const QString & szMsg);

        void outputProxyMessage(const QString & szMsg);

        void outputProxyError(const QString & szMsg);

        void outputSocketMessage(const QString & szMsg);

        void outputSocketWarning(const QString & szMsg);

        void outputSocketError(const QString & szMsg);
protected slots:
        void connectionTimedOut();

        void writeNotifierFired(int);

        void readData(int);

        void readProxyData(int);

        void readHttpProxyErrorData(int);

        void flushSendQueue();

        void doSSLHandshake(int);
};

#endif //_KVI_IRCSOCKET_H_