ExtensionBlock.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 "ExtensionBlock.h"
#include "Extension.h"
#include "GgepBlock.h"
#include "Xml.h"
#include "Urn.h"
#include "UnknownExtension.h"

using namespace Gnutella::Packets::Extensions;

ExtensionBlock::ExtensionBlock()
{
}

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

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

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

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

    return *this;
}

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

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

void ExtensionBlock::addExtension (const Extension &extension)
{
    extensions_.append (extension.copy());
}

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


bool ExtensionBlock::prepareRead (const QByteArray &rawData)
{
    deleteExtensions();

    if (rawData.size() == 0)
        return true;

    int rawDataLength = rawData.length();
    int currentPos = 0;
    while (currentPos < rawDataLength) {
        QByteArray rawExtensionData = QByteArray::fromRawData (rawData.data() + currentPos, rawDataLength - currentPos);
        Extension *extension = 0;

        switch (rawData[currentPos])
        {
        case Xml::StartByte:
            extension = new Xml;
            break;
        case Urn::StartByte:
            extension = new Urn;
            break;
        case GgepBlock::MagicByte:
            extension = new GgepBlock;
            break;
        default:
            extension = new UnknownExtension;
        }
        int extensionLength = extension->prepareRead (rawExtensionData);
        /*  There is no way to recover if we fail to parse an extension, so
            just treat the rest as an unknown extension. The same is true when
            we do not find the ExtensionSeparator after the last read extension.
        */
        if (extensionLength == 0
            || (currentPos + extensionLength < rawDataLength
                && rawData[currentPos + extensionLength] != ExtensionSeparator)) {
            delete extension;
            extension = new UnknownExtension();
            extensionLength = extension->prepareRead (rawExtensionData);
        }
        extensions_.append (extension);
        currentPos += extensionLength;
        if (currentPos < rawDataLength)
            currentPos++; // ExtensionSeparator is only there BETWEEN extensions. Never at the end.
    }
    return true;
}

void ExtensionBlock::read (QDataStream &stream)
{
    bool isFirst = true;
    foreach (const Extension *extension, extensions_) {
        uchar tmp;
        if (isFirst)
            isFirst = false;
        else
            stream >> tmp; // Read out the ExtensionSeparator
        const_cast <Extension *> (extension)->read (stream);
    }
}

int ExtensionBlock::prepareWrite() const
{
    int totalLength = 0;
    foreach (const Extension *extension, extensions_)
        totalLength += extension->prepareWrite() + 1; // Extension followed by ExtensionSeparator.

    // There is no ExtensionSeparator after the last extension.
    if (totalLength > 0)
        totalLength--;

    return totalLength;
}

void ExtensionBlock::write (QDataStream &stream) const
{
    bool isFirst = true;
    foreach (const Extension *extension, extensions_) {
        if (isFirst)
            isFirst = false;
        else
            stream << static_cast <uchar> (ExtensionSeparator);
        extension->write (stream);
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.