connection.h

Go to the documentation of this file.

/*     -*-C++-*- -*-coding: utf-8-unix;-*-
    Classified Ads is Copyright (c) Antti Järvinen 2013.

    This file is part of Classified Ads.

    Classified Ads is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    Classified Ads 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with Classified Ads; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/


#ifndef CONNECTION_H
#define CONNECTION_H
#include <QTcpSocket> // for SocketError
#include <QHostAddress> // for ipv6 addr type
#include "protocol.h"
#include "node.h"

class QSslSocket ;
class QByteArray ;
class MController ;
class Model ;
class QSslError ; 

class Connection : public QObject {
    Q_OBJECT
public:
    enum ConnectionState {
        Initial, 
        Open,    
        Closing, 
        Error    
    };
    class ConnectionObserver {
    public:
        virtual bool dataReceived(const QByteArray& aData,
                                  Connection& aConnection ) = 0 ;
        virtual void connectionClosed(Connection *aDeletee) = 0 ;
        virtual void connectionReady(Connection *aBusinessEntity) = 0 ;
    } ;
    Connection(int aSocketDescriptor,
               ConnectionObserver& aObserver,
               Model& aModel,
               MController& aController);
    Connection(const QHostAddress& aAddr,
               const int aPort,
               ConnectionObserver &aObserver,
               Model& aModel,
               MController& aController,
               const Hash& aFpOfNodeToTry ) ;
    ~Connection() ;
    static bool Ipv6AddressesEqual(const Q_IPV6ADDR& aAddr1,
                                   const Q_IPV6ADDR& aAddr2) ;
    Node* node() const {
        return iNodeOfConnectedPeer ;
    }

    void setNode(Node* aNode) {
        iNodeOfConnectedPeer = aNode ;
    }

    QHostAddress peerAddress() const ;

    const Hash& fingerPrintOfNodeAttempted() ;
    ConnectionState connectionState() const  {
        return iConnectionState;
    }
    ProtocolItemType stageOfBucketFill() const {
        return iStageOfBucketFill ;
    }
    void setStageOfBucketFill(ProtocolItemType aStage)  {
        iStageOfBucketFill = aStage ;
    }

    bool isInbound() const {
        return iSocketIsIncoming ;
    }  ;
    time_t getOpenTime() const {
        return iSocketOpenTime ;
    }  ;
    Hash getPeerHash() const ;
    unsigned long bytesIn() const {
        return iBytesIn ;
    }
    unsigned long bytesOut() const {
        return iBytesOut ;
    }
    bool forciblyCloseSocket() ;
    bool isInPrivateAddrSpace() const ;
public slots:
    void socketReady() ;
    void run() ;
    void encryptedBytesWritten ( qint64 written ) ; 
    void sslErrors ( const QList<QSslError> & errors ) ; 
    void socketError ( QAbstractSocket::SocketError socketError ) ; 
    void disconnected () ; 
    void readyRead () ; 
signals:
    void error(QTcpSocket::SocketError socketError);
    void finished() ;
    void blackListNetworkAddr(QHostAddress aAddr) ;
    void connectionAttemptFailed(const Hash& aNodeHash) ;
protected:
    void performRead() ;
    void readLoop() ; 
    void runForIncomingConnections() ;
    void runForOutgoingConnections() ;
    void checkForBucketFill() ;
    void flushSocket() ; 
    void setupSocketSignals() ; 
public:// these are public because datamodel access these, via lock()
    QList <SendQueueItem> iSendQueue ;
    QList<QByteArray *> iNextProtocolItemToSend ;
public:
    bool iNeedsToRun ; 
    time_t iTimeOfLastActivity ; 
    unsigned iNumberOfPacketsReceived ; 
  static const unsigned iMinutesBetweenBucketFill = 30  ; 
protected: // these are not public
    void msleep(int aMilliSeconds) ; 
    ConnectionState iConnectionState  ;
    ConnectionObserver &iObserver ;
    QSslSocket *iSocket ;
    Model& iModel ; 
    quint32 iBytesExpectedInPacketBeingRead ;
    QByteArray *iBytesRead ;
    int iInvocationsSinceLastByteReceived;
    Node *iNodeOfConnectedPeer ;
    QHostAddress iAddrToConnect ;
    const int iPortToConnect ;
    const int iSocketDescriptor ;
    const bool iSocketIsIncoming ;
    MController& iController ;
    Hash iFpOfNodeWeTrying ;
    ProtocolItemType iStageOfBucketFill ;
    quint32 iTimeOfBucketFill ;
    Hash iEndOfBucket ;
    const time_t iSocketOpenTime ;
    unsigned long iBytesIn ;
    unsigned long iBytesOut ;
    QHostAddress iPeerAddress ;
    int iBytesPendingWrite ; 
    int iSleepBetweenSendOperations ; 
    Hash iPeerHash;
} ;
#endif