PacketRouter.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 "PacketRouter.h"
#include "Gnutella/Packets/Packet.h"
#include "Gnutella/Packets/Query.h"
#include "Gnutella/Packets/QueryHits.h"
#include "Gnutella/Packets/Push.h"

// \todo rename class to GuidRouter

using Gnutella::PacketProcessing::PacketRouter;
using Gnutella::PacketProcessing::PacketSession;
using Gnutella::Packets::Packet;
using Gnutella::Packets::QueryDescriptor;
using Gnutella::Packets::QueryHitsDescriptor;
using Gnutella::Packets::PushDescriptor;
using Gnutella::Packets::Query;
using Gnutella::Packets::QueryHits;
using Gnutella::Packets::Push;

enum RouterConstants
{
    DefaultQueryExpiration      = 60 * 10,  // 10 min
    DefaultQueryHitsExpiration  = 60 * 30,  // 30 min
    ExpirationTimerInterval     = 1000 * 60 // 60 sec;
};

PacketRouter::PacketRouter()
 :  queryPaths(), queryHitsPaths(), queryStatusRequestPaths(),
    queryExpirations(), queryHitsExpirations(),
    queryStatusRequestExpirations(), expirationTimer()
{
    QObject::connect (&expirationTimer, SIGNAL (timeout ()), this, SLOT (clearExpiredPaths ()));
    expirationTimer.setInterval (ExpirationTimerInterval);
    expirationTimer.start();
}

PacketRouter::~PacketRouter()
{
}

bool PacketRouter::isDuplicate (const Packet &packet)
{
    using namespace Gnutella::Packets;
    switch (packet.payloadDescriptor())
    {
    case QueryDescriptor:
        {
            PacketPaths::iterator it = queryPaths.find (packet.descriptorId());
            if (it != queryPaths.end())
                return true;
            return false;
        }
    case QueryHitsDescriptor:
    case PushDescriptor:
        // \todo Implement, for now just fall through...
    // The rest are not routed.
    case PingDescriptor:
    case PongDescriptor:
    case ByeDescriptor:
    case IbmcDescriptor:
    case QueryRoutingDescriptor:
    case OpenVendorDescriptor:
    case StandardVendorDescriptor:
    default:
        return false;
    }
}

void PacketRouter::addQueryPath (const Query &query, PacketSession *session)
{
    const QUuid &descriptorId = query.descriptorId();
    PacketPaths::iterator it = queryPaths.find (descriptorId);

    if (it == queryPaths.end()) {
        it = queryPaths.insert (descriptorId, new PathSet);
        QTime expirationTime = QTime::currentTime().addSecs (DefaultQueryExpiration);
        queryExpirations.push_back (new Expiration (descriptorId, expirationTime));
    }
    (*it)->insert (session);
}

void PacketRouter::addQueryHitsPath (const QueryHits &queryHits, PacketSession *session)
{
    const QUuid &serventId = queryHits.serventId();
    PacketPaths::iterator it = queryHitsPaths.find (serventId);

    if (it == queryHitsPaths.end()) {
        it = queryHitsPaths.insert (serventId, new PathSet);
        QTime expirationTime = QTime::currentTime().addSecs (DefaultQueryHitsExpiration);
        queryExpirations.push_back (new Expiration (serventId, expirationTime));
    }
    (*it)->insert (session);
}

void PacketRouter::addQueryStatusRequestPath (const Packet &packet, PacketSession *session)
{
    const QUuid &serventId = packet.descriptorId();
    PacketPaths::iterator it = queryStatusRequestPaths.find (serventId);

    if (it == queryStatusRequestPaths.end()) {
        it = queryStatusRequestPaths.insert (serventId, new PathSet);
        QTime expirationTime = QTime::currentTime().addSecs (DefaultQueryHitsExpiration);
        queryExpirations.push_back (new Expiration (serventId, expirationTime));
    }
    (*it)->insert (session);
}

PacketRouter::Paths PacketRouter::queryHitsRoutePaths (const Packet &packet)
{
    const QUuid &descriptorId = packet.descriptorId();
    PacketPaths::iterator it = queryPaths.find (descriptorId);
    if (it != queryPaths.end())
        return (*it)->values().toSet();
    else
        return Paths();
}

PacketRouter::Paths PacketRouter::pushRoutePaths (const Push &push)
{
    const QUuid &serventId = push.serventId();
    PacketPaths::iterator it = queryHitsPaths.find (serventId);
    if (it != queryHitsPaths.end())
        return  (*it)->values().toSet();
    else
        return Paths();
}

PacketRouter::Paths PacketRouter::queryStatusResponsePaths (const Packet &packet)
{
    const QUuid &serventId = packet.descriptorId();
    PacketPaths::iterator it = queryStatusRequestPaths.find (serventId);
    if (it != queryStatusRequestPaths.end())
        return  (*it)->values().toSet();
    else
        return Paths();
}

void PacketRouter::clearExpiredPaths()
{
    QTime currentTime = QTime::currentTime();

    Expiration *expiration = 0;
    while (!queryExpirations.isEmpty()) {
        expiration = queryExpirations.front();
        if (expiration->second > currentTime)
            break;

        queryExpirations.pop_front();
        PacketPaths::iterator it = queryPaths.find (expiration->first);
        if (it != queryPaths.end()) {
            delete (*it);
            queryPaths.remove (expiration->first);
        }
        delete expiration;
    }

    while (!queryHitsExpirations.isEmpty()) {
        expiration = queryHitsExpirations.front();
        if (expiration->second > currentTime)
            break;

        queryHitsExpirations.pop_front();
        PacketPaths::iterator it = queryHitsPaths.find (expiration->first);
        if (it != queryHitsPaths.end()) {
            delete (*it);
            queryHitsPaths.remove (expiration->first);
        }
        delete expiration;
    }

    while (!queryStatusRequestExpirations.isEmpty()) {
        expiration = queryStatusRequestExpirations.front();
        if (expiration->second > currentTime)
            break;

        queryStatusRequestExpirations.pop_front();
        PacketPaths::iterator it = queryStatusRequestPaths.find (expiration->first);
        if (it != queryStatusRequestPaths.end()) {
            delete (*it);
            queryStatusRequestPaths.remove (expiration->first);
        }
        delete expiration;
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.