HandshakeSession.h

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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.

Calitko 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 Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef GNUTELLA__HANDSHAKING__HANDSHAKE_SESSION_H
#define GNUTELLA__HANDSHAKING__HANDSHAKE_SESSION_H

#include "Imports.h"

namespace Gnutella {
namespace Handshaking {

class Handshaker;

// \todo Put in the class HandshakeSession
enum RejectReason
{
    NotRejecting,
    RejectNoSlots,
    RejectUnsupportedFeatures,
    RejectImUltrapeer,
    RejectImLeaf
};

enum HandshakeError
{
    NoError,
    ErrorCannotEstablishConnection,
    ErrorRemoteClosedConnection,
    ErrorRemoteNodeRejected,
    ErrorRejectedByRemoteNode,
    ErrorInvalidHeadersRead,
    ErrorWriteDevice,
    ErrorReadDevice,
    ErrorTimeout
};


class HandshakeSession : public QObject
{
    Q_OBJECT

public:
            HandshakeSession (Connection *, const NodeAddress &,
                              Handshaker *, NodeCache *);
            ~HandshakeSession();

    void    request (const NodeInfo &myNodeInfo);
    void    waitRequest();
    void    respond (const NodeInfo &myNodeInfo);
    void    waitResponse();
    void    acknowledge (const NodeInfo &myNodeInfo);
    void    waitAcknowledgement();
    void    reject (RejectReason, const NodeInfo &myNodeInfo);

    NodeInfo        otherNodeInfo() const;
    NodeInfo        myNodeInfo() const;
    Connection *    connection() const;
    HandshakeError  error() const;

signals:
    void    connectionEstablished (HandshakeSession *);
    void    receivedRequest (HandshakeSession *);
    void    receivedResponse (HandshakeSession *);
    void    handshakingCompleted (HandshakeSession *);
    void    handshakingFailed (HandshakeSession *);

private slots:
    void    connectionEstablished();
    void    connectionFailed();
    void    connectionClosed(); 
    void    handshakeRead();        
    void    handshakeWritten(); 
    void    readError();            
    void    writeError();           
    void    timeout ();             

private:

    enum State
    {
        UnknownState,
        WaitingPhase1Handshake,
        SendingPhase1Handshake,
        WaitingPhase2Handshake,
        SendingPhase2Handshake,
        WaitingPhase3Handshake,
        SendingPhase3Handshake,
        RejectingConnection,
        HandshakingTimedOut,
        HandshakingFailed,
        HandshakingCompleted
    };

    void    completed();
    void    failed (HandshakeError);
    void    sendResponse (RejectReason, const NodeInfo &); // \todo Maybe rename the type of the argument?
    void    setHandshakeHeaders (Header &handshakeHeaders, const NodeInfo &myNodeInfo);
    void    getHandshakeHeaders (const Header &handshakeHeaders);

    struct Data
    {
        Handshaker      *handshaker;
        NodeCache       *nodeCache;
        HeaderReader    *reader;
        HeaderWriter    *writer;
        Connection      *connection;
        State           state;
        HandshakeError  error;
        QTimer          timer;
        NodeInfo        myNodeInfo;
        NodeInfo        otherNodeInfo;

        Data() : handshaker (0), nodeCache (0), reader (0), writer (0),
                 connection (0), state (UnknownState), error (NoError),
                 timer(), myNodeInfo(), otherNodeInfo()
        {}

    private:
        REFERENCE_OBJECT (Data)
    };

    Data d;
};

inline NodeInfo HandshakeSession::myNodeInfo() const
{ return d.myNodeInfo; }

inline NodeInfo HandshakeSession::otherNodeInfo() const
{ return d.otherNodeInfo; }

inline Connection * HandshakeSession::connection() const
{ return d.connection; }

inline HandshakeError HandshakeSession::error() const
{ return d.error; }

} // namespace Handshaking
} // namespace Gnutella

#endif // GNUTELLA__HANDSHAKING__HANDSHAKE_SESSION_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.