PongHandler.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-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 "PongHandler.h"
#include "NodeCache.h"
#include "UdpHostCache.h"
#include "Imports.cpp"

using namespace Gnutella::Bootstrapping;

PongHandler::PongHandler (LocalPeer *localPeer)
 :  d()
{
    d.nodeCache     = localPeer->nodeCache();
    d.udpHostCache  = localPeer->udpHostCache();
}

PongHandler::~PongHandler()
{
}

void PongHandler::processPong (const Pong &pong)
{
    NodeInfo nodeInfo;
    nodeInfo.address = NodeAddress (pong.ipAddress(), pong.port());
    NodeCache::NodeAvailability availability = NodeCache::UnknownAvailability;
    // Distinguish between pongs that are surely connectable, s.a. directly
    //connected neighbors and such that are merely forwarded by a neighbor.
    // \todo Does the above make sence now when the UDP pongs are also
    // flowed through here?
    if (pong.hops() == 0)
        availability = NodeCache::NodeAvailable;

    using Gnutella::Packets::Extensions::Ggeps::DailyUptime;
    const DailyUptime *ggepDailyUptime = DailyUptime::findIn (pong.ggepBlock());
    if (ggepDailyUptime != 0) {
        nodeInfo.dailyUptime = ggepDailyUptime->dailyUptime();
    }

    using Gnutella::Packets::Extensions::Ggeps::Ultrapeer;
    const Ultrapeer *ultrapeer = Ultrapeer::findIn (pong.ggepBlock());
    if (ultrapeer != 0) {
        nodeInfo.type = TypeUltrapeer;
        nodeInfo.freeUltrapeerSlots = ultrapeer->ultrapeerSlots();
        nodeInfo.freeLeafSlots = ultrapeer->leafSlots();
        nodeInfo.serventVersion = Utils::Version (ultrapeer->version());
    }

    using Gnutella::Packets::Extensions::Ggeps::VendorCode;
    const VendorCode *vendorCode = VendorCode::findIn (pong.ggepBlock());
    if (vendorCode != 0) {
        nodeInfo.vendorCode = vendorCode->vendorCode();
        nodeInfo.serventVersion = Version (vendorCode->version());
    }

    using Gnutella::Packets::Extensions::Ggeps::IpPort;
    const IpPort *ipPort = IpPort::findIn (pong.ggepBlock());
    if (ipPort != 0) {
        foreach (NodeAddress address, ipPort->addresses()) {
            if (address == NodeAddress::Null)
                continue;
            NodeInfo nodeInfo;
            nodeInfo.type = TypeUltrapeer; // \todo depends on the SCP we sent!
            nodeInfo.address = address;
            d.nodeCache->addNode (nodeInfo, NodeCache::UnknownAvailability);
        }
    }

    using Gnutella::Packets::Extensions::Ggeps::PackedHostCaches;
    const PackedHostCaches *phc = PackedHostCaches::findIn (pong.ggepBlock());
    if (phc != 0) {
        foreach (NodeAddress address, phc->addresses()) {
            qDebug () << "PHC " << address.hostAddress().toString()
                      << pong.port() << address.hostPort();
            d.udpHostCache->addCache (address);
        }
    }

    using Gnutella::Packets::Extensions::Ggeps::UdpHostCache;
    const UdpHostCache *udphc = UdpHostCache::findIn (pong.ggepBlock());
    // The pong is either for a normal host or an UdpHostCache
    if (udphc != 0) {
        // \todo Add to udp host cache
        qDebug () << "UDPHC " << pong.ipAddress().toString()
                  << pong.port() << udphc->hostName();
        NodeAddress uhcAddress;
        uhcAddress.setHostName (udphc->hostName());
        uhcAddress.setHostPort (pong.port());
        d.udpHostCache->addCache (uhcAddress);
    } else if (nodeInfo.address != NodeAddress::Null) {
        d.nodeCache->addNode (nodeInfo, availability);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.