QrtReader.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 "QrtReader.h"
#include "QueryRoutingTable.h"
#include "Imports.cpp"

using namespace Gnutella::PacketProcessing::QueryRouting;

namespace Gnutella {
namespace PacketProcessing {
namespace QueryRouting {

class QrtReaderPrivate
{
    REFERENCE_OBJECT (QrtReaderPrivate)

public:
    QueryRoutingTable       currentTable;
    bool                    isReset;
    bool                    isUpdating;
    quint8                  infinity;
    quint8                  entryBits;
    quint32                 tableSize;
    bool                    isCompressed;
    QByteArray              rawUpdateTable;

    QrtReaderPrivate() :    currentTable(), isReset (false), isUpdating (false),
                            infinity (0), entryBits (0), tableSize (0),
                            isCompressed (false), rawUpdateTable()
    {}
};

} // QueryRouting
} // PacketProcessing
} // Gnutella

const QueryRoutingTable & QrtReader::currentTable() const
{ return p->currentTable; }

QrtReader::QrtReader()
 :  p (new QrtReaderPrivate)
{
    p->currentTable.reset (8);
    p->isUpdating = false;
}

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

bool QrtReader::handlePacket (const Packet &packet)
{
    using namespace Gnutella::Packets;
    if (packet.payloadDescriptor() != QueryRoutingDescriptor)
        return false;
    const Packets::QueryRouting &qrp = Packets::QueryRouting::castFrom (packet);
    switch (qrp.variant())
    {
    case Packets::QueryRouting::ResetVariant:
        processReset (QueryRoutingReset::castFrom (packet));
        break;
    case Packets::QueryRouting::PatchVariant:
        processPatch (QueryRoutingPatch::castFrom (packet));
        break;
    case Packets::QueryRouting::UnknownVariant:
    default:
        break;
    }
    return true;
}

void QrtReader::processReset (const QueryRoutingReset &reset)
{
    p->isReset = true;
    p->tableSize = reset.tableLength();
    p->infinity = reset.infinity();


}

void QrtReader::processPatch (const QueryRoutingPatch &patch)
{
    if (patch.seqNo() == 1) {
        p->isUpdating = true;
        p->rawUpdateTable.resize (0);
        p->entryBits = patch.entryBits();
        p->isCompressed = patch.compressor() == QueryRoutingPatch::ZLIB;

    }

    p->rawUpdateTable.append (patch.data());

    if (patch.seqNo() == patch.seqSize())
        completeTableUpdate();
}

void QrtReader::completeTableUpdate()
{
    if (p->isCompressed)
        p->rawUpdateTable = unCompress (p->rawUpdateTable);

    // Check whether the received patch matches the expected values.
    if (p->rawUpdateTable.size() * 8 != qint32 (p->entryBits * p->tableSize)) {
        return;
    }

    if (p->isReset) {
        p->currentTable.reset (p->tableSize);
    }
    if (p->tableSize != p->currentTable.size()) {
        return;
    }
    p->currentTable.applyPatch (p->rawUpdateTable, p->entryBits);

    emit qrtRead();

    p->isReset = false;
    p->isUpdating = false;
    p->rawUpdateTable.resize (0);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.