GgepBlock.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 "GgepBlock.h"
#include "Ggep.h"

using namespace Gnutella::Packets::Extensions;

GgepBlock::GgepBlock()
 :  Extension(), extensions_(), rawBlockLength_()
{
    setIsValid (true);
}

GgepBlock::GgepBlock (const GgepBlock &block)
 :  Extension(), extensions_(), rawBlockLength_()
{
    foreach (const Ggep *extension, block.extensions_)
        addExtension (*extension);
}

GgepBlock * GgepBlock::copy() const
{
    return new GgepBlock (*this);
}

GgepBlock& GgepBlock::operator= (const GgepBlock &block)
{
    if (this == &block)
        return *this;

    foreach (const Ggep *extension, extensions_)
        delete extension;

    extensions_.clear();
    foreach (const Ggep *extension, block.extensions_)
        addExtension (*extension);

    return *this;
}

GgepBlock::~GgepBlock()
{
    deleteExtensions();
}

void GgepBlock::deleteExtensions()
{
    foreach (const Ggep *extension, extensions_)
        delete extension;
    extensions_.clear();
}

int GgepBlock::prepareRead (const QByteArray &rawData)
{
    deleteExtensions();

    setIsValid (false);
    int rawDataSize = rawData.size();
    rawBlockLength_ = rawDataSize;

     // Minimal size is 1 (MagicByte) + 1 (Flags) + 1 (ID) + 1 (Data Length)
    if (rawDataSize < 4)
        return 0;

    int currentPos = 0;
    if (rawData[currentPos++] != MagicByte)
        return 0;

    bool isLastExtension = false;
    while (!isLastExtension) {
        // Read the extension header.
        uchar flags = rawData[currentPos++];
        isLastExtension = flags & Ggep::LastExtension;
        int idLength = flags & Ggep::IDLength;

        // Check minimal required rawData size. Still need to read the ID and at least 1 size byte.
        if (currentPos + idLength + 1 > rawDataSize)
            return 0;

        Ggep::GgepId id (rawData.data() + currentPos, idLength);
        currentPos += idLength;

        int dataLength = 0;
        bool readMore = false;
        int bytesRead = 0;
        do {
            char byte = rawData[currentPos++];
            dataLength = (dataLength << 6) | (byte & 0x3F);
            readMore = (byte & 0x40) != 0x40;
            bytesRead++;
        } while (readMore && bytesRead < 3 && currentPos < rawDataSize);
        // Could not finish reading the data length:
        if (readMore)
            return 0;
        // Less than dataLength bytes left to read:
        if (currentPos + dataLength > rawDataSize)
            return 0;

        if (currentPos + dataLength == rawDataSize)
            isLastExtension = true;

        currentPos += dataLength; // Move pointer to the first byte of the next extension.

        Ggep *extension = Ggep::fromId (id, flags, dataLength);
        Q_ASSERT (extension != 0);
        extensions_.append (extension);

        // Ggep::prepareRead() requires the raw extension data, WITHOUT header.
        // We checked the header already.
        // \todo Maybe do the header parsing again in Ggep, or ONLY there?
        int rawExtensionDataStart = currentPos - dataLength;
        int rawExtensionDataLength = currentPos - rawExtensionDataStart;
        QByteArray extensionData = QByteArray::fromRawData (rawData.data() + rawExtensionDataStart, rawExtensionDataLength);
        // \todo Should we mark the block as invalid is a single extension is invalid, aka. prepareRead fails?
        extension->prepareRead (extensionData);
    }
    setIsValid (true);
    return currentPos;
}

void GgepBlock::read (QDataStream &stream)
{
    // For packets, which may have optional GGEP blocks somewhere in the middle
    // of the payload it is important to advance the stream pointer with a number
    // of bytes exactly equal to the expected GGEP block size. That also needs to
    // be done in the case when the GGEP block is invalid or is missing.
    if (!isValid()) {
        deleteExtensions();
        QByteArray buffer;
        buffer.resize (rawBlockLength_); // Missing GGEP block would mean zero length.
        stream.readRawData (buffer.data(), rawBlockLength_);
        return;
    }

    uchar temp;
    stream >> temp; // MagicByte

    Q_ASSERT (temp == uchar (MagicByte));

    /*
        We store const Ggep * although we may require non-const access
        to the objects, like in this case. We require an ugly cast here, but ease
        the implementation and increase the performance of extensions(). Otherwise,
        we sould either keep two lists (one const and one non-const), or would have
        to create a new const one each time extensions() is called.
    */
    Ggep *extension = 0;
    foreach (const Ggep *constExtension, extensions_) {
        extension = const_cast <Ggep *> (constExtension);
        extension->read (stream);
    }
}

int GgepBlock::prepareWrite() const
{
    if (extensions_.count() == 0)
        return 0;

    int writeBytesCount = 1; // MagicByte.

    foreach (const Ggep * extension, extensions_) {
        writeBytesCount += extension->prepareWrite();
    }
    return writeBytesCount;
}

void GgepBlock::write (QDataStream &stream) const
{
    if (extensions_.count() == 0)
        return;

    stream << static_cast <uchar> (MagicByte);

    foreach (const Ggep * extension, extensions_) {
        extension->write (stream);
    }
}

void GgepBlock::addExtension (const Ggep &extension)
{
    Ggep *newExtension = extension.copy();
    newExtension->setFlag (Ggep::LastExtension);

    if (extensions_.size() > 0) {
        Ggep *oldLastExtension = const_cast <Ggep *> (extensions_.last());
        oldLastExtension->resetFlag (Ggep::LastExtension);
    }
    extensions_.append (newExtension);
}

GgepBlock::Extensions GgepBlock::extensions() const
{
    return extensions_;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.