HandshakeSession.cpp

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

*/

#include "Qt.h"
#include "HandshakeSession.h"
#include "Handshaker.h"
#include "RequestHeader.h"
#include "ResponseHeader.h"
#include "Imports.cpp"

using namespace Gnutella::Handshaking;

namespace Gnutella {
namespace Handshaking {

// \todo Maybe define these in package Http
static const int        CodeOK                              = 200;
static const int        CodeNotAcceptable                   = 406;
static const int        CodeBusy                            = 503;

struct StatusLine
{
    int     code;
    QString phrase;
};

static const StatusLine statusLines[] = {
{ CodeOK,               "OK" }, // NotRejecting
{ CodeBusy,             "No Slots Available" }, // RejectNoSlots
{ CodeNotAcceptable,    "You Don't Support Required Features" }, //RejectUnsupportedFeatures,
{ CodeNotAcceptable,    "I'm an Ultrapeer" }, //RejectImUltrapeer,
{ CodeNotAcceptable,    "I'm a Shielded Leaf" } //RejectImLeaf,
}; // statusLines[]

enum Constants
{
    HandshakingTimeout  = 10000,
    TryUltrapeersCount  = 20
};

} // Handshaking;
} // Gnutella;

HandshakeSession::HandshakeSession (Connection *connection,
                                    const NodeAddress & othersAddress,
                                    Handshaker *handshaker,
                                    NodeCache *nodeCache)
 :  d()
{
    d.handshaker            = handshaker;
    d.nodeCache             = nodeCache;
    d.reader                = new HeaderReader (connection);
    d.writer                = new HeaderWriter (connection);
    d.connection            = connection;
    d.state                 = UnknownState;
    d.error                 = NoError;
    d.otherNodeInfo.address = othersAddress;

    // If we will try to establish the connection, then updateCache:
    if (othersAddress != NodeAddress::Null)
        d.nodeCache->updateNode (othersAddress, NodeCache::CheckingAvailability);

    connect (d.connection,  SIGNAL  (connectionEstablished()),
             this,          SLOT    (connectionEstablished()));
    connect (d.connection,  SIGNAL  (connectionFailed()),
             this,          SLOT    (connectionFailed()));
    connect (d.connection,  SIGNAL  (connectionClosed()),
             this,          SLOT    (connectionClosed()));
    connect (d.reader,      SIGNAL  (headerRead()),
             this,          SLOT    (handshakeRead()));
    connect (d.reader,      SIGNAL  (readError()),
             this,          SLOT    (readError()));
    connect (d.writer,      SIGNAL  (headerWritten()),
             this,          SLOT    (handshakeWritten()));
    connect (d.writer,      SIGNAL  (writeError()),
             this,          SLOT    (writeError()));

    connect (&d.timer, SIGNAL (timeout()), this, SLOT (timeout()));
    d.timer.setSingleShot (true);
    d.timer.setInterval (HandshakingTimeout);
}

HandshakeSession::~HandshakeSession()
{
    qDebug() << "HandshakeSession::~HandshakeSession()";

    d.reader->disconnect (this);
    d.writer->disconnect (this);
    d.timer.disconnect (this);

    d.timer.stop();

    delete d.reader;
    delete d.writer;

    qDebug() << "HandshakeSession::~HandshakeSession() exit";
}

inline void HandshakeSession::completed()
{
    d.state = HandshakingCompleted;
    d.error = NoError;

    if (d.otherNodeInfo.address != NodeAddress::Null)
        d.nodeCache->addNode (d.otherNodeInfo, NodeCache::NodeAvailable);
    else if (d.connection->remoteNodeAddress() != NodeAddress::Null)
        d.nodeCache->updateNode (d.connection->remoteNodeAddress(),
                                 NodeCache::NodeUnavailable);
    emit handshakingCompleted (this);
}

inline void HandshakeSession::failed (HandshakeError error)
{
    if (d.state == HandshakingFailed)
        return;

    d.state = HandshakingFailed;
    d.error = error;

    // \todo NodeBusy or NodeUnavailable depending on error!
    if (d.otherNodeInfo.address != NodeAddress::Null)
        d.nodeCache->updateNode (d.otherNodeInfo.address,
                                 NodeCache::NodeUnavailable);
    else if (d.connection->remoteNodeAddress() != NodeAddress::Null)
        d.nodeCache->updateNode (d.connection->remoteNodeAddress(),
                                 NodeCache::NodeUnavailable);

    // Defer emitting the error signal until the connection is closed (see the
    // slot connectionClosed()))

    // Now close only if already connected. If establishing a connection failed
    // then connectionFailed() will emit the error signal itself.
    if (error != ErrorCannotEstablishConnection)
        d.connection->disconnectFromNode();
}

void HandshakeSession::request(const NodeInfo &myNodeInfo)
{
    d.state = SendingPhase1Handshake;

    RequestHeader request (0, 6); // \todo use constants
    setHandshakeHeaders (request, myNodeInfo);
    qDebug() << "Write:\n" << request.toString(); // Maybe put in writer?
    d.timer.start();
    d.writer->write (request);
}

void HandshakeSession::waitRequest()
{
    d.state = WaitingPhase1Handshake;
    d.timer.start();
    d.reader->startReading (new RequestHeader);
}

void HandshakeSession::sendResponse (RejectReason reason, const NodeInfo &myNodeInfo)
{
    int     code    = statusLines [reason].code;
    QString phrase  = statusLines [reason].phrase;
    ResponseHeader response (code, phrase, 0, 6); // \todo version as consts
    setHandshakeHeaders (response, myNodeInfo);
    qDebug() << "Write:\n" << response.toString();
    d.writer->write (response);
}

void HandshakeSession::respond (const NodeInfo &myNodeInfo)
{
    d.state = SendingPhase2Handshake;
    sendResponse (NotRejecting, myNodeInfo);
}

void HandshakeSession::waitResponse()
{
    d.state = WaitingPhase2Handshake;
    d.reader->startReading (new ResponseHeader);
}

void HandshakeSession::waitAcknowledgement()
{
    d.state = WaitingPhase3Handshake;
    d.reader->startReading (new ResponseHeader);
}

void HandshakeSession::acknowledge (const NodeInfo &nodeInfo)
{
    d.state = SendingPhase3Handshake;
    sendResponse (NotRejecting, nodeInfo);
}

void HandshakeSession::reject (RejectReason reason, const NodeInfo &myNodeInfo)
{
    d.state = RejectingConnection;
    sendResponse (reason, myNodeInfo);
}

void HandshakeSession::handshakeRead()
{
    const Header *handshake = d.reader->header();
    qDebug() << "Read:\n" << handshake->toString();
    getHandshakeHeaders (*handshake);

    const RequestHeader *request =
            dynamic_cast <const RequestHeader *> (handshake);
    const ResponseHeader *response =
            dynamic_cast <const ResponseHeader *> (handshake);

    // Badly formatted headers received, abort handshaking.
    if ((request == 0 && d.state == WaitingPhase1Handshake)
        || (response == 0 && d.state != WaitingPhase1Handshake)) {
        failed (ErrorInvalidHeadersRead);
    } else if (response && response->statusCode() != CodeOK) {
        failed (ErrorRejectedByRemoteNode);
    } else if (d.state == WaitingPhase1Handshake) {
        emit receivedRequest (this);
    } else if (d.state == WaitingPhase2Handshake) {
        emit receivedResponse (this);
    } else if (d.state == WaitingPhase3Handshake) {
        completed();
    } else {
        Q_ASSERT (false);
    }
}

void HandshakeSession::readError()
{
    qDebug() << "HandshakeSession::readError()";
    failed (ErrorReadDevice);
}

void HandshakeSession::handshakeWritten()
{
    switch (d.state)
    {
    case SendingPhase1Handshake:
        waitResponse();
        break;
    case SendingPhase2Handshake:
        waitAcknowledgement();
        break;
    case SendingPhase3Handshake:
        completed();
        break;
    case RejectingConnection:
        failed (ErrorRemoteNodeRejected);
        break;
    case UnknownState:
    case WaitingPhase1Handshake:
    case WaitingPhase2Handshake:
    case WaitingPhase3Handshake:
    case HandshakingTimedOut:
    case HandshakingFailed:
    case HandshakingCompleted:
    default:
        Q_ASSERT (false);
        break;
    }
}

void HandshakeSession::writeError()
{
    qDebug() << "HandshakeSession::writeError()";
    failed (ErrorWriteDevice);
}

void HandshakeSession::connectionEstablished()
{
    qDebug() << "HandshakeSession::connectionEstablished()";
    emit connectionEstablished (this);
}

void HandshakeSession::connectionFailed()
{
    qDebug() << "HandshakeSession::connectionFailed()";
    failed (ErrorCannotEstablishConnection);
    emit handshakingFailed (this);
}

void HandshakeSession::connectionClosed()
{
    qDebug() << "HandshakeSession::connectionClosed()";
    d.timer.stop();
    d.timer.disconnect (this);
    // If we have not been in failed() already (in other words did not defer
    // emitting the error signal), then do the fail case work:
    if (d.state != HandshakingFailed)
        failed (ErrorRemoteClosedConnection);
    // We defered emitting the signal until the connection was finally closed.
    // Now we emit only if we did not already think handshaking succeeded (that
    // could happen if events get queued in a special order).
    if (d.state != HandshakingCompleted)
        emit handshakingFailed (this);
}

void HandshakeSession::timeout()
{
    qDebug() << "HandshakeSession::timeout()";
    failed (ErrorTimeout);
}

void HandshakeSession::setHandshakeHeaders (Header &header, const NodeInfo &myNodeInfo)
{
    // User-Agent
    if (d.myNodeInfo.identification != myNodeInfo.identification)
        header.setFieldValue ("User-Agent", myNodeInfo.identification);
    if (d.state == SendingPhase1Handshake
        || d.state == SendingPhase2Handshake) {
        // Listen-IP
        header.setFieldValue ("Listen-IP", myNodeInfo.address.toString());

        // Remote-IP (only on request or response)
        d.otherNodeInfo.address = d.connection->remoteNodeAddress();
        QString remoteIp = d.otherNodeInfo.address.hostAddress().toString();
        header.setFieldValue ("Remote-IP", remoteIp);
    }
    // X-Ultrapeer
    {
        bool isUltrapeer = myNodeInfo.type != TypeLeaf;
        header.setFieldValue ("X-Ultrapeer", isUltrapeer ? "true" : "false");
    }
    // X-Ultrapeer-Needed - may have changed in last phase, if we just allocated
    // the last slot for this peer, so do not print it.
    if (d.myNodeInfo.ultrapeerNeeded != myNodeInfo.ultrapeerNeeded
        && d.state != SendingPhase3Handshake) {
        QString neededString = myNodeInfo.ultrapeerNeeded ? "true" : "false";
        header.setFieldValue ("X-Ultrapeer-Needed", neededString);
    }

    if (d.state == SendingPhase1Handshake
        || d.state == SendingPhase2Handshake) {
        header.setFieldValue ("Pong-Caching",
                              myNodeInfo.pongCaching.toString());
        header.setFieldValue ("GGEP",
                              myNodeInfo.ggep.toString());
        header.setFieldValue ("X-Query-Routing",
                              myNodeInfo.queryRouting.toString());
        header.setFieldValue ("X-Ultrapeer-Query-Routing",
                              myNodeInfo.ultrapeerQueryRouting.toString());
        header.setFieldValue ("X-Dynamic-Querying",
                              myNodeInfo.dynamicQuerying.toString());
        header.setFieldValue ("X-Degree",
                              QString ("%1").arg (myNodeInfo.degree));
        header.setFieldValue ("X-Max-TTL",
                              QString ("%1").arg (myNodeInfo.maxTtl));
        header.setFieldValue ("X-Requeries", "false");
        //haeder.setFieldValue ("X-Version", "?.?");
        header.setFieldValue ("Vendor-Message",
                              myNodeInfo.vendorMessage.toString());
        //header.setFieldValue ("X-Ext-Probes", "0.1");
        header.setFieldValue ("Bye-Packet",
                              myNodeInfo.byePacket.toString());
        //header.setFieldValue ("Accept-Encoding", "deflate");
    }
    // Only write X-Try-Ultrapeers on phase 2, i,e when accepting a connection:
    if (d.state == SendingPhase2Handshake) {
        NodeSet addresses = d.nodeCache->getNodes (TryUltrapeersCount,
                                                   NodeCache::NodeAvailable,
                                                   true);
        foreach (NodeAddress address, addresses) {
            header.addFieldValue ("X-Try-Ultrapeers", address.toString());
        }
    }
    d.myNodeInfo = myNodeInfo;
}

void HandshakeSession::getHandshakeHeaders (const Header &header)
{
    if (header.hasField ("User-Agent")) {
        d.otherNodeInfo.identification = header.fieldValue ("User-Agent");
    }
    if (header.hasField ("Listen-IP")) {
        QString listenIp = header.fieldValue ("Listen-IP");
        d.otherNodeInfo.address = NodeAddress (listenIp);
    }
    if (header.hasField ("Remote-IP")) {
        QHostAddress remoteIp = QHostAddress (header.fieldValue ("Remote-IP"));
        d.handshaker->setVisibleIp (remoteIp);
        d.myNodeInfo.address.setHostAddress (remoteIp);
    }
    if (header.hasField ("X-Ultrapeer")) {
        bool isUltrapeer = header.fieldValue ("X-Ultrapeer").toLower() == "true";
        d.otherNodeInfo.type = isUltrapeer ? TypePeer : TypeLeaf;
        if (isUltrapeer && d.myNodeInfo.type == TypeLeaf)
            d.otherNodeInfo.type = TypeUltrapeer;
    }
    if (header.hasField ("X-Ultrapeer-Needed")) {
        d.otherNodeInfo.ultrapeerNeeded = header.fieldValue ("X-Ultrapeer-Needed").toLower() == "true";
    } else {
        d.otherNodeInfo.ultrapeerNeeded = true; // true if field is missing.
    }
    if (header.hasField ("X-Try") || header.hasField ("X-Try-Ultrapeers")) {
        QStringList values = header.fieldValues("X-Try");
        values += header.fieldValues("X-Try-Ultrapeers");
        for (int i = values.size() - 1; i >= 0; i--) {
            using Gnutella::Bootstrapping::NodeCache;
            NodeAddress nodeAddress (values.at (i));
            NodeInfo nodeInfo;
            nodeInfo.address = nodeAddress;
            d.nodeCache->addNode (nodeInfo, NodeCache::UnknownAvailability);
        }
    }
    if (header.hasField ("GGEP")) {
        QString version = header.fieldValue ("GGEP");
        d.otherNodeInfo.ggep = Version (version);
    }
    if (header.hasField ("X-Query-Routing")) {
        QString version = header.fieldValue ("X-Query-Routing");
        d.otherNodeInfo.queryRouting = Version (version);
    }
    if (header.hasField ("X-Ultrapeer-Query-Routing")) {
        QString version = header.fieldValue ("X-Ultrapeer-Query-Routing");
        d.otherNodeInfo.ultrapeerQueryRouting = Version (version);
    }
    if (header.hasField ("Bye-Packet")) {
        QString version = header.fieldValue ("Bye-Packet");
        d.otherNodeInfo.byePacket = Version (version);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.