LocalPeer.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 "LocalPeer.h"
#include "Http/Header.h"
#include "Gnutella/Bootstrapping/ConnectionKeeper.h"
#include "Gnutella/Bootstrapping/NodeCache.h"
#include "Gnutella/Bootstrapping/PingHandler.h"
#include "Gnutella/Bootstrapping/PongHandler.h"
#include "Gnutella/Bootstrapping/UdpHostCache.h"
#include "Protocols/Transports/TcpConnection.h"
#include "Protocols/Transports/UdpConnection.h"
#include "Protocols/Transports/UdpSwitch.h"
#include "Gnutella/Handshaking/Handshaker.h"
#include "Gnutella/Handshaking/SlotAllocator.h"
#include "Gnutella/PacketProcessing/PacketProcessor.h"
#include "Gnutella/PacketProcessing/PongCache.h"
#include "Gnutella/Packets/Extensions/Ggeps/DailyUptime.h"
#include "Gnutella/Packets/Query.h"
#include "Gnutella/Searching/LocalSearch.h"
#include "Gnutella/Searching/Searcher.h"
#include "UIs/NodeModel.h"
#include "PacketModel.h"
#include "UIs/Searching/SearchModel.h"

using Gnutella::LocalPeer;
using Gnutella::LocalPeerPrivate;
using Gnutella::NodeInfo;
using Gnutella::Bootstrapping::ConnectionKeeper;
using Gnutella::Bootstrapping::NodeCache;
using Gnutella::Bootstrapping::PingHandler;
using Gnutella::Bootstrapping::PongHandler;
using Gnutella::Bootstrapping::UdpHostCache;
using Protocols::Transports::Connection;
using Protocols::Transports::TcpConnection;
using Protocols::Transports::UdpConnection;
using Protocols::Transports::UdpSwitch;
using Gnutella::Handshaking::HandshakeError;
using Gnutella::Handshaking::Handshaker;
using Gnutella::Handshaking::SlotAllocator;
using Gnutella::PacketProcessing::PacketProcessor;
using Gnutella::Searching::LocalSearch;
using Gnutella::Searching::Searcher;
using UIs::Searching::SearchModel;


// \todo that should be superfluos now - p is initialized correctly in the
// initialization list of the LocalPeer ctor.
class Gnutella::Workaround {
public:
    Workaround (LocalPeer *lp, LocalPeerPrivate *p)
    { lp->p = p; }
};

class LocalPeerPrivate
{
public:
    Workaround                  workaround; // \todo avoid!
    NodeCache                   nodeCache;
    UdpHostCache                udpHostCache;
    Handshaker                  handshaker;
    ConnectionKeeper            connectionKeeper;
    SlotAllocator               slotAllocator;
    LocalSearch                 localSearch;
    Searcher                    searcher;
    PacketProcessor             packetProcessor;
    PingHandler                 pingHandler;
    PongHandler                 pongHandler;

    NodeInfo                    nodeInfo;
    bool                        serverIsFirewalled;

    QTcpServer                  server;
    UdpSwitch                   udpSwitch;

    NodeModel                   nodeModel;
    PacketModel                 packetModel;

    LocalPeerPrivate (LocalPeer *localPeer)
      : workaround (localPeer, this),
        nodeCache(),
        udpHostCache (&udpSwitch, &pingHandler),
        handshaker (localPeer, &nodeCache, &slotAllocator),
        connectionKeeper (localPeer),
        slotAllocator (localPeer),
        localSearch (localPeer, &packetProcessor),
        searcher (localPeer),
        packetProcessor (localPeer),
        pingHandler (localPeer),
        pongHandler (localPeer),
        nodeInfo(),
        serverIsFirewalled (false),
        server(),
        udpSwitch(),
        nodeModel(),
        packetModel()
    {
        nodeInfo.type = Gnutella::TypeUltrapeer;
        //nodeInfo.type = Gnutella::TypeLeaf;

        qRegisterMetaType <qint64> ("qint64"); // \todo maybe move elsewhere - needed by handshake/packet wirters
    }
};

LocalPeer::LocalPeer()
 : p (new LocalPeerPrivate (this))
{
    connect (&p->slotAllocator, SIGNAL (handshakingSlotFreed()),
             &p->connectionKeeper, SLOT (keepConnection()));
    connect (&p->slotAllocator, SIGNAL (ultrapeerSlotFreed()),
             &p->connectionKeeper, SLOT (keepConnection()));
    connect (&p->slotAllocator, SIGNAL (peerSlotFreed()),
             &p->connectionKeeper, SLOT (keepConnection()));
    connect (&p->packetProcessor, SIGNAL (receivedPong (const Pong &)),
             &p->pongHandler, SLOT (processPong (const Pong &)));
    connect (&p->packetProcessor, SIGNAL (receivedQueryHits (const QueryHits &)),
             &p->searcher, SLOT (processQueryHits (const QueryHits &)));
    connect (&p->packetProcessor, SIGNAL (processQueryStatusRequest (const QueryStatusRequest &)),
             &p->searcher, SLOT (processQueryStatusRequest (const QueryStatusRequest &)));
    connect (&p->udpHostCache, SIGNAL (receivedPong (const Pong &)),
             &p->pongHandler, SLOT (processPong (const Pong &)));
    connect (&p->udpSwitch, SIGNAL (connectionAccepted (UdpConnection *)),
             &p->udpHostCache, SLOT (connectionAcceptedSlot (UdpConnection *)));
    connect (&p->handshaker, SIGNAL (handshakingStarted (Connection *)),
             &p->nodeModel, SLOT (setHandshaking (Connection *)));
    connect (&p->handshaker, SIGNAL (handshakingCompleted (Connection *, NodeInfo)),
             &p->nodeModel, SLOT (setConnected (Connection *, NodeInfo)));
    connect (&p->handshaker, SIGNAL (handshakingCompleted (Connection *, NodeInfo)),
             &p->packetProcessor, SLOT (addConnection (Connection *, NodeInfo)));
}

LocalPeer::~LocalPeer()
{
    disconnectFromNetwork();
    delete p;
}

bool LocalPeer::isUltrapeer() const
{ return p->nodeInfo.type == TypeUltrapeer; }

QHostAddress LocalPeer::serverIpAddress() const
{ return p->nodeInfo.address.hostAddress(); }

quint16 LocalPeer::serverPort() const
{ return p->nodeInfo.address.hostPort(); }

const NodeInfo & LocalPeer::nodeInfo() const
{ return p->nodeInfo; }

UdpHostCache * LocalPeer::udpHostCache()
{ return &p->udpHostCache; }

SlotAllocator * LocalPeer::slotAllocator()
{ return &p->slotAllocator; }

NodeCache * LocalPeer::nodeCache()
{ return &p->nodeCache; }

PacketProcessor * LocalPeer::packetProcessor()
{ return &p->packetProcessor; }

Searcher* LocalPeer::searcher()
{ return &p->searcher; }

QAbstractItemModel * LocalPeer::nodeModel()
{ return &p->nodeModel; }

QAbstractItemModel * LocalPeer::packetModel()
{ return &p->packetModel; }

bool LocalPeer::connectToNetwork()
{
    // <pd_todo> Add error notifications (maybe signals?)
    if (p->nodeInfo.address.hostPort() == 0)
        return false;

    connect (&p->server, SIGNAL(newConnection()), this, SLOT(newConnection()));
    if (!p->server.listen (QHostAddress::Any, p->nodeInfo.address.hostPort()))
        return false;

    setServerIpAddress (p->server.serverAddress());

    // If the second argument is true, and the signal udpSwitch::connectionAccepted()
    // is not connected, some resources would be leaked.
    p->udpSwitch.start (NodeAddress (QHostAddress::Any, p->nodeInfo.address.hostPort()), true);

    p->nodeCache.loadNodes (tr ("hosts.dat"));

    p->connectionKeeper.bootstrap();
    return true;
}

void LocalPeer::setServerIpAddress (const QHostAddress &ipAddress)
{
    // \todo How to determine our firewall status?
    // \todo Whould we chech whether we are connecteed before updating the pongCache?
    p->nodeInfo.address.setHostAddress (ipAddress);
    /*if (!serverIsFirewalled)
        pongCache.setHostAddress (serverIpAddress);
    else
        pongCache.setHostAddress (QHostAddress::Null);
    */
}

void LocalPeer::setServerPort (quint16 port)
{
    // \todo Whould we chech whether we are connecteed before updating the pongCache?
    p->nodeInfo.address.setHostPort (port);
    /*if (!serverIsFirewalled)
        pongCache.setHostPort (serverPort);
    else
        pongCache.setHostPort (0);
    */
}

bool LocalPeer::disconnectFromNetwork()
{
    p->nodeCache.storeNodes (tr ("hosts.dat"));
    // \todo Delegate to handshaker and packetProcessor
    return true;
}

void LocalPeer::connectToPeer (const QString &hostName, quint16 port)
{
    qDebug() << "Connecting to " << hostName << ":" << port;

    TcpConnection *connection = new TcpConnection;
    NodeAddress nodeAddress = NodeAddress (hostName, port);
    p->nodeModel.nodeConnecting (connection, nodeAddress);
    p->handshaker.requestConnection (connection, nodeAddress);
}

void LocalPeer::disconnectFromPeer (Connection *connection)
{
    connection->disconnectFromNode();
}

void LocalPeer::newConnection()
{
    QTcpSocket *socket = p->server.nextPendingConnection();
    qDebug() << "Accepting connection from " << socket->peerAddress().toString() << ":" << socket->peerPort();
    // \todo Peek some data to make sure whether this is a handshake or transfer connection
    acceptHandshakeConnection (socket);
}

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

    NodeAddress nodeAddress = connection->remoteNodeAddress();

    p->nodeModel.nodeConnecting (connection, nodeAddress);
    p->handshaker.acceptConnection (connection);
}

// \todo Just pass a query string. Create a packet here!
void LocalPeer::startSearch (SearchModel *searchModel, QString &query)
{
     searcher()->startSearch (searchModel, query);
}

void LocalPeer::stopSearch (SearchModel *searchModel)
{
     searcher()->stopSearch (searchModel);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.