HandshakerTester.cpp

Go to the documentation of this file.

#include <QObject>
#include "Handshaker.h"
#include "SlotAllocator.h"
#include "Gnutella/LocalPeer.h"
#include "Gnutella/Bootstrapping/NodeCache.h"
#include "Networks/Transports/TcpConnection.h"


using namespace Gnutella;

using Gnutella::Handshaking::Handshaker;
using Gnutella::Handshaking::SlotAllocator;
using Gnutella::Bootstrapping::NodeCache;
using Networks::Transports::Connection;
using Networks::Transports::TcpConnection;


class HandshakerTester : public QObject
{
    Q_OBJECT

public:
            HandshakerTester (QCoreApplication *, quint16,NodeType);
            ~HandshakerTester();
    void    listenToNetwork();
    void    connectToNetwork();


private slots:
    void    newConnection();
    void    handshakingCompleted (Connection *, NodeInfo);
    void    handshakingFailed (Connection *, Gnutella::Handshaking::HandshakeError);
    void    acceptHandshakeConnection (QTcpSocket *);

private:
    QCoreApplication    *app;
    LocalPeer           *localPeer;
    NodeCache           *nodeCache;
    SlotAllocator       *slotAllocator;
    Handshaker          *handshaker;
    TcpConnection       *tcpConnection;
    quint16             port;
    QTcpServer          *server;
};

HandshakerTester::HandshakerTester (QCoreApplication *app_ , quint16 port_,NodeType type)
{
    app             = app_;
    port            = port_;

    localPeer       = new LocalPeer (type,port);
    nodeCache       = new NodeCache;
    slotAllocator   = new SlotAllocator (localPeer);
    handshaker      = new Handshaker (localPeer, nodeCache, slotAllocator);
    tcpConnection   = new TcpConnection;
    server          = new QTcpServer();

   QObject::connect (handshaker, SIGNAL (handshakingCompleted (Connection *, NodeInfo)),
             this, SLOT (handshakingCompleted (Connection *, NodeInfo)));
    QObject::connect (handshaker, SIGNAL (handshakingFailed (Connection *, Gnutella::Handshaking::HandshakeError)),
             this, SLOT (handshakingFailed (Connection *, Gnutella::Handshaking::HandshakeError)));
    QObject::connect (server, SIGNAL(newConnection()), this, SLOT(newConnection()));


}



HandshakerTester::~HandshakerTester()
{
    delete handshaker;
    delete slotAllocator;
    delete nodeCache;
    delete localPeer;
    delete server;
}

void HandshakerTester::connectToNetwork()
{
    //nodeCache->loadNodes ("hosts.dat");
    NodeAddress nodeAddress ("127.0.0.1",port);
    handshaker->requestConnection (tcpConnection, nodeAddress);

}


void HandshakerTester::listenToNetwork()
{

    server->listen(QHostAddress::Any,port);
}

void HandshakerTester::handshakingCompleted (Connection *, NodeInfo)
{
    delete tcpConnection;
    server->close();

    //app->quit();
}

void HandshakerTester::handshakingFailed (Connection *, Gnutella::Handshaking::HandshakeError)
{
    // tcpConnection was already deleted by handshaker
    //app->quit();
    server->close();
}

void HandshakerTester::newConnection()
{
    QTcpSocket *socket = server->nextPendingConnection();
    qDebug() << "Accepting connection from " << socket->peerAddress().toString() << ":" << socket->peerPort();
    acceptHandshakeConnection (socket);
}

void HandshakerTester::acceptHandshakeConnection (QTcpSocket *socket)
{
    Connection      *connection     = new TcpConnection (socket);

    handshaker->acceptConnection (connection);
}


int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    qRegisterMetaType<qint64>("qint64");

    HandshakerTester handshakeTesterServer (&app,1000,TypeLeaf);
    HandshakerTester handshakeTesterClient (&app,1000,TypeLeaf);
    qDebug() << "Listening to port 1000";
    handshakeTesterServer.listenToNetwork();
    qDebug() << "connecting to port 1000";
    handshakeTesterClient.connectToNetwork();
    return app.exec();
}

#include "HandshakerTester.moc"

Copyright © 2006 Peter Dimov.
Powered by Doxygen.