Handshaker.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 "Handshaker.h"
#include "HandshakeSession.h"
#include "RequestHeader.h"
#include "ResponseHeader.h"
#include "SlotAllocator.h"
#include "Imports.cpp"

using namespace Gnutella::Handshaking;

namespace Gnutella {
namespace Handshaking {

class HandshakerPrivate
{
    REFERENCE_OBJECT (HandshakerPrivate)

public:
    typedef QSet <HandshakeSession *>       HandshakeSessions;

    NodeInfo                                nodeInfo; // NodeInfo for our node.
    LocalPeer                               *localPeer;
    NodeCache                               *nodeCache;
    SlotAllocator                           *slotAllocator;
    HandshakeSessions                       sessions;

    HandshakerPrivate() : nodeInfo(), localPeer (0), nodeCache (0),
                          slotAllocator (0), sessions()
    {}
};

} // namespace Handshaking;
} // namespace Gnutella;

Handshaker::Handshaker (LocalPeer *localPeer,
                        NodeCache *nodeCache,
                        SlotAllocator *slotAllocator)
 :  p (new HandshakerPrivate)
{
    p->localPeer = localPeer;
    p->nodeCache = nodeCache;
    p->slotAllocator = slotAllocator;


    // Initialize  our node info:
    p->nodeInfo.address.setHostPort (localPeer->serverPort());
    p->nodeInfo.type = localPeer->nodeInfo().type;
    p->nodeInfo.identification = "Calitko/0.6.1";
    //p->nodeInfo.ultrapeerNeeded = slotAllocator->hasFreePeerSlots();
    p->nodeInfo.pongCaching = Version (0, 1);
    p->nodeInfo.ggep = Version (0, 5);
    p->nodeInfo.queryRouting = Version (0, 1);
    p->nodeInfo.ultrapeerQueryRouting = Version (0, 1);
    p->nodeInfo.dynamicQuerying = Version (0, 1);
    //d.nodeInfo.guess = Version (0, 1);
    p->nodeInfo.vendorMessage = Version (0, 1);
    //d.nodeInfo.extProbes = Version (0, 1);
    p->nodeInfo.byePacket = Version (0, 1);
    p->nodeInfo.degree = 32;
    p->nodeInfo.maxTtl = 3;
    //p->encoding = QString ("deflate");
}

Handshaker::~Handshaker()
{
    delete p;
}

HandshakeSession * Handshaker::newSession (Connection *connection,
                                           const NodeAddress &nodeAddress)
{
    // \todo That's a workaround to get the value update. Fix it.
    p->nodeInfo.address.setHostPort (p->localPeer->serverPort());
    p->nodeInfo.ultrapeerNeeded = p->slotAllocator->hasFreePeerSlots();
    p->nodeInfo.type = p->localPeer->nodeInfo().type;

    // \todo Perform some check whether connection is given for the second time?
    HandshakeSession *session = 0;
    session = new HandshakeSession (connection, nodeAddress,
                                    this, p->nodeCache);
    p->sessions.insert (session);

    connect (session, SIGNAL (connectionEstablished (HandshakeSession *)),
             this, SLOT (connectionEstablished (HandshakeSession *)));
    connect (session, SIGNAL (receivedRequest (HandshakeSession *)),
             this, SLOT (receivedRequest (HandshakeSession *)));
    connect (session, SIGNAL (receivedResponse (HandshakeSession *)),
             this, SLOT (receivedResponse (HandshakeSession *)));
    connect (session, SIGNAL (handshakingCompleted (HandshakeSession *)),
             this, SLOT (handshakingCompleted (HandshakeSession *)));
    connect (session, SIGNAL (handshakingFailed (HandshakeSession *)),
             this, SLOT (handshakingFailed (HandshakeSession *)));

    return session;
}

void Handshaker::deleteSession (HandshakeSession *session)
{
    Q_ASSERT (p->sessions.contains (session));
    p->sessions.remove (session);
    session->disconnect (this);
    session->deleteLater();
}

void Handshaker::requestConnection (Connection *connection,
                                    const NodeAddress & nodeAddress)
{
    qDebug() << "Handshaker::requestConnection()";

    HandshakeSession *session = newSession (connection, nodeAddress);
    p->slotAllocator->allocateSlot (session);
    /*  \todo When HandshakeSession is created it initializes its otherNode.address
        member to the remoteAddress of the connection, which in this case here is
        not connected! Therefore if the connection attempt fails, the address remains
        Null, which causes that a Null address is added to the NodeCache, which is
        absolustely wrong! Now a workaround is that addNode returns without adding a
        Null address! Better would be to make sure you never pass it a Null address! */
    connection->connectToNode (nodeAddress);

    qDebug() << "Handshaker::requestConnection() done";
}

void Handshaker::acceptConnection (Connection *connection)
{
    HandshakeSession *session = newSession (connection, NodeAddress::Null);
    p->slotAllocator->allocateSlot (session);
    session->waitRequest();
}

void Handshaker::connectionEstablished (HandshakeSession *session)
{
    Connection *connection = session->connection();
    emit handshakingStarted (connection);
    session->request (p->nodeInfo);
}

void Handshaker::handshakingCompleted (HandshakeSession *session)
{
    Connection *connection = session->connection();
    NodeInfo nodeInfo = session->otherNodeInfo();
    connection->disconnect (session); // better add a releaseConnection() function to session and do that there.
    deleteSession (session); // Disconnect all session's slots here.
    emit handshakingCompleted (connection, nodeInfo);
}

void Handshaker::handshakingFailed (HandshakeSession *session)
{
    qDebug() << "Handshaker::failedHandshaking" << session;

    Connection *connection = session->connection();
    HandshakeError error = session->error();
    NodeInfo nodeInfo = session->otherNodeInfo();
    connection->disconnect (session); // better add a releaseConnection() function to session and do that there.
    deleteSession (session); // Disconnect all session's slots here.
    connection->deleteLater();
    // \todo connection is already deleted! Do we need the signal at all? Not now at least! Maybe LocalPeer should delete the connections after all?
    emit handshakingFailed (connection, error);
}

bool Handshaker::hasRequiredFeatures (const NodeInfo &nodeInfo)
{
    // Does not support ultrapeers (no X-Ultrapeer header field)
    // \todo Handle Crawlers correctly!
    if (nodeInfo.type == TypeUnknown)
        return false;
    if (nodeInfo.type == TypeLeaf
        && nodeInfo.queryRouting.minorVersion() < 1)
        return false;
    if (nodeInfo.type == TypePeer
        && nodeInfo.ultrapeerQueryRouting.minorVersion() < 1)
        return false;
    return true;
}

bool Handshaker::compatibleNodeTypes (const NodeInfo &otherNodeInfo)
{
    if (p->nodeInfo.type == TypeLeaf) {
        return otherNodeInfo.type == TypeUltrapeer;
    }
    if (p->nodeInfo.type == TypeUltrapeer || p->nodeInfo.type == TypePeer) {
        if (otherNodeInfo.type == TypePeer)
            return otherNodeInfo.ultrapeerNeeded == true;
        else
            return true;
    }
    Q_ASSERT (false);
    return false;
}

int Handshaker::getRejectReason (HandshakeSession *session)
{
    NodeInfo otherNodeInfo = session->otherNodeInfo();
    if (!hasRequiredFeatures (otherNodeInfo))
        return RejectUnsupportedFeatures;
    if (!compatibleNodeTypes (otherNodeInfo)) {
        if (p->nodeInfo.type == TypeLeaf)
            return RejectImLeaf;
        else
            return RejectImUltrapeer;
    } else if (!p->slotAllocator->hasSlotFor (otherNodeInfo))
        return RejectNoSlots;
    else
        return NotRejecting;
}

void Handshaker::receivedRequest (HandshakeSession *session)
{
    p->nodeInfo.address.setHostAddress (session->myNodeInfo().address.hostAddress());
    RejectReason reason = static_cast <RejectReason> (getRejectReason (session));
    if (reason != NotRejecting)
        session->reject (reason, p->nodeInfo);
    else {
        session->respond (p->nodeInfo);
    }
}

void Handshaker::receivedResponse (HandshakeSession *session)
{
    p->nodeInfo.address.setHostAddress (session->myNodeInfo().address.hostAddress());
    RejectReason reason = static_cast <RejectReason> (getRejectReason (session));
    if (reason != NotRejecting)
        session->reject (reason, p->nodeInfo);
    else {
        session->acknowledge (p->nodeInfo);
    }
}

void Handshaker::setVisibleIp (const QHostAddress &address)
{
    p->localPeer->setServerIpAddress (address);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.